Comment faire un tableau / hachage associatif en JavaScript

574

J'ai besoin de stocker des statistiques en utilisant JavaScript d'une manière comme je le ferais en C #:

Dictionary<string, int> statistics;

statistics["Foo"] = 10;
statistics["Goo"] = statistics["Goo"] + 1;
statistics.Add("Zoo", 1);

Existe-t-il un Hashtableou quelque chose comme Dictionary<TKey, TValue>en JavaScript?
Comment pourrais-je stocker des valeurs de cette manière?

George2
la source
1
js est vaguement tapé, donc il n'y a aucun moyen de simplement déclarer une chaîne ou un int, vous pouvez simplement déclarer un var et lui affecter une chaîne ou un int. : D
Gordon Gustafson
Vous voudrez peut-être consulter xDict. jsfiddle.net/very/MuVwd Il s'agit d'un dictionnaire String => tout ce qui est écrit en Javascript.
Robert
Cet article a une excellente explication de la façon dont les tableaux associatifs sont implémentés sous le capot en Javascript jayconrod.com/posts/52/a-tour-of-v8-object-representation
Shuklaswag
La réponse acceptée a été écrite en 2009 - elle ne prend en charge que les clés de chaîne . Pour les clés non-chaîne, utilisez Map ou WeakMap, comme dans la réponse de Vitalii .
ToolmakerSteve

Réponses:

565

Utilisez des objets JavaScript comme tableaux associatifs .

Tableau associatif: en termes simples, les tableaux associatifs utilisent des chaînes au lieu de nombres entiers comme index.

Créez un objet avec

var dictionary = {};

Javascript vous permet d'ajouter des propriétés aux objets en utilisant la syntaxe suivante:

Object.yourProperty = value;

Une syntaxe alternative pour le même est:

Object["yourProperty"] = value;

Si vous pouvez également créer une clé pour évaluer les cartes d'objets avec la syntaxe suivante

var point = { x:3, y:2 };

point["x"] // returns 3
point.y // returns 2

Vous pouvez parcourir un tableau associatif en utilisant la construction de boucle for..in comme suit

for(var key in Object.keys(dict)){
  var value = dict[key];
  /* use key/value for intended purpose */
}
Alek Davis
la source
36
Notez que l'approche de l'auteur d'initialiser un "tableau associatif" avec new Array()est désapprouvée. L'article mentionne finalement ses inconvénients et suggère new Object()ou {}comme alternatives préférées, mais c'est presque la fin et je crains que la plupart des lecteurs n'iront pas aussi loin.
Daniel Lubarov
24
Échouer. JavaScript ne prend pas en charge les références d'objet en tant que clés, contrairement à quelque chose comme le dictionnaire Flash / AS3. En JavaScript, var obj1 = {}; var obj2 = {}; var table= {}; table[obj1] = "A"; table[obj2] = "B"; alert(table[obj1]); //displays Bcar il ne peut pas différencier les clés obj1 et obj2; ils sont tous les deux convertis en chaîne et deviennent juste quelque chose comme "Object". Total échoue et rend la sérialisation sécurisée avec les références et les références cycliques intactes difficiles ou non performantes en JavaScript. C'est facile dans Flash / AS3.
Triynko
Eh bien, la seule façon dans JS que nous pouvons valider en vérifiant l'égalité ou en définissant une méthode d' égalité par quelque chose comme ceci: Point.prototype.equals = function(obj) { return (obj instanceof Point) && (obj.x === this.x) && (obj.y === this.y); };
Nadeem
1
@Leo console.log ({A: 'B', C: 'D'} [foo]) devrait vous donner A B.
ychaouche
2
@Leo L'exemple semble erroné. for... incar un dictionnaire fera une boucle sur ses clés, il Object.keyssemble donc mal placé. Object.keysrenvoie un tableau des clés du dictionnaire, et for... inpour un tableau boucle sur ses "clés", qui pour un tableau sont ses indices, pas ses valeurs.
JHH
434
var associativeArray = {};
associativeArray["one"] = "First";
associativeArray["two"] = "Second";
associativeArray["three"] = "Third";

Si vous venez d'un langage orienté objet, vous devriez consulter cet article .

Dani Cricco
la source
38
Vous pouvez également le faire en moins de lignes: var associativeArray = {"one": "First", "two": "second", "three": "Third"}; Ensuite, associativeArray ["one"] renvoie "First" et assocativeArray ["four"] renvoie null.
Tony Wickham
2
Désolé @JuusoOhtonen, j'ai écrit le post il y a 6 ans (c'est incroyable la vitesse à laquelle le temps passe). J'ai mis à jour le lien. Veuillez le vérifier et n'hésitez pas à demander si vous avez des doutes
Dani Cricco
145

Tous les navigateurs modernes prennent en charge un objet Carte javascript . Il y a plusieurs raisons qui rendent l'utilisation d'une carte meilleure que l'objet:

  • Un objet a un prototype, il y a donc des clés par défaut dans la carte.
  • Les clés d'un objet sont des chaînes, où elles peuvent être n'importe quelle valeur pour une carte.
  • Vous pouvez facilement obtenir la taille d'une carte tout en gardant une trace de la taille d'un objet.

Exemple:

var myMap = new Map();

var keyObj = {},
    keyFunc = function () {},
    keyString = "a string";

myMap.set(keyString, "value associated with 'a string'");
myMap.set(keyObj, "value associated with keyObj");
myMap.set(keyFunc, "value associated with keyFunc");

myMap.size; // 3

myMap.get(keyString);    // "value associated with 'a string'"
myMap.get(keyObj);       // "value associated with keyObj"
myMap.get(keyFunc);      // "value associated with keyFunc"

Si vous souhaitez que les clés qui ne sont pas référencées à partir d'autres objets soient récupérées, pensez à utiliser un WeakMap au lieu d'une carte.

Vitalii Fedorenko
la source
5
Espérons que dans quelques années ce sera la réponse la plus votée.
Cameron Lee
1
@CameronLee sûrement ça va
Loïc Faure-Lacroix
1
Ceci Mapest à peine utile lorsque votre clé est un objet mais doit être comparé par valeur et non par référence.
Siyuan Ren
7
Plus d'un an après la rédaction de cette réponse, il n'est PAS vrai que "tous les navigateurs modernes prennent en charge Map". Ce n'est que sur le bureau que vous pouvez compter sur au moins un support de base de la carte. Pas sur les appareils mobiles. Par exemple, le navigateur Android ne prend pas du tout en charge Map. Même sur le bureau, certaines implémentations sont incomplètes. Par exemple, IE11 ne prend toujours pas en charge l'énumération via "for ... of ...", donc si vous voulez une compatibilité IE, vous devez utiliser le dégoûtant .forEach kludge. De plus, JSON.stringify () ne fonctionne pas pour Map dans les navigateurs que j'ai essayés. De plus, les initialiseurs ne fonctionnent pas dans IE ou Safari.
Dave Burton
3
Il existe une excellente prise en charge du navigateur. Revérifier. Dans tous les cas, c'est assez facile à remplir, donc la prise en charge du navigateur natif n'est pas un problème.
Brad
132

Sauf si vous avez une raison spécifique de ne pas le faire, utilisez simplement un objet normal. Les propriétés des objets en Javascript peuvent être référencées à l'aide d'une syntaxe de style table de hachage:

var hashtable = {};
hashtable.foo = "bar";
hashtable['bar'] = "foo";

Les éléments fooet barpeuvent maintenant être référencés comme:

hashtable['foo'];
hashtable['bar'];
// or
hashtable.foo;
hashtable.bar;

Bien sûr, cela signifie que vos clés doivent être des chaînes. S'ils ne sont pas des chaînes, ils sont convertis en interne en chaînes, donc cela peut toujours fonctionner, YMMV.

roryf
la source
1
Les clés sous forme d'entiers ne m'ont posé aucun problème. stackoverflow.com/questions/2380019/…
Jonas Elfström
10
Jonas: gardez à l'esprit que vos entiers sont convertis en chaînes lors de la définition de la propriété: var hash = {}; hash[1] = "foo"; alert(hash["1"]);alertes "foo".
Tim Down du
17
Et si l'une de vos clés est " proto " ou " parent "?
PleaseStand
5
Notez que les objets ne peuvent pas être utilisés comme clés en JavaScript. Eh bien, ils le peuvent, mais ils sont convertis en leurs représentations String, donc tout objet se retrouvera exactement comme la même clé. Voir la suggestion jshashtable de @ TimDown ci-dessous.
ericsoco
21
Cet exemple est déroutant car vous utilisez foo et bar comme clé et valeur dans deux cas. Il est beaucoup plus clair de montrer que var dict = {}; dict.key1 = "val1"; dict["key2"] = "val2";l'élément key1 de dict peut être référencé de manière équivalente par les deux dict["key1"]et dict.key1.
Jim
49

Puisque chaque objet dans JS se comporte comme - et est généralement implémenté comme - une table de hachage, je vais juste avec ça ...

var hashSweetHashTable = {};
Shog9
la source
26
Voté car il ne montre pas comment accéder réellement aux valeurs de la "table de hachage".
IQAndreas
J'ai 9 ans de retard (je ne connaissais pas grand-chose à la programmation, et encore moins à ce site à l'époque), mais ... Et si vous essayez de stocker des points sur une carte et que vous avez besoin de voir si quelque chose est déjà à un point sur une carte? Dans ce cas, vous feriez mieux d'utiliser HashTable pour cela, en recherchant par coordonnées (un objet , pas une chaîne ).
Mike Warren
@MikeWarren if (hashSweetHashTable.foo)doit entrer le bloc if si fooest défini.
Koray Tugay
21

donc en C # le code ressemble à:

Dictionary<string,int> dictionary = new Dictionary<string,int>();
dictionary.add("sample1", 1);
dictionary.add("sample2", 2);

ou

var dictionary = new Dictionary<string, int> {
    {"sample1", 1},
    {"sample2", 2}
};

en JavaScript

var dictionary = {
    "sample1": 1,
    "sample2": 2
}

L'objet dictionnaire C # contient des méthodes utiles comme dictionary.ContainsKey() en JavaScript, nous pourrions utiliser le hasOwnPropertymême

if (dictionary.hasOwnProperty("sample1"))
    console.log("sample1 key found and its value is"+ dictionary["sample1"]);
Raj
la source
1
Vote positif pour moi n'ayant pas à écrire de réponse surhasOwnProperty
brichins
18

Si vous souhaitez que vos clés soient n'importe quel objet plutôt que de simples chaînes, vous pouvez utiliser mon jshashtable .

Tim Down
la source
3
Combien d'heures ai-je passé à trébucher sur le fait que les objets ne peuvent pas vraiment être utilisés comme clés pour des tableaux d'objets de style JS en tant qu'associatifs avant de trouver cela? Merci, Tim.
ericsoco
1
Le dictionnaire Flash / AS3, avec la plupart des autres langues, prend en charge les références d'objet sous forme de clés. JavaScript ne l'a pas encore implémenté, mais je pense que c'est dans une future spécification comme une sorte de classe Map. Encore une fois avec les polyfills en attendant; tant pour les normes. Oh, attendez ... enfin en 2015, la carte semble être arrivée: stackoverflow.com/a/30088129/88409 , et est prise en charge par les navigateurs "modernes", lol: kangax.github.io/compat-table/es6/# Carte (et pas vraiment largement prise en charge). Seulement une décennie derrière AS3.
Triynko
Tim, vous devriez peut-être mettre à jour jshashtable pour utiliser Map () lorsque cela est disponible.
Dave Burton
1
@DaveBurton: Bon plan. Je le ferai dès que j'aurai du temps.
Tim Down du
6
function HashTable() {
    this.length = 0;
    this.items = new Array();
    for (var i = 0; i < arguments.length; i += 2) {
        if (typeof (arguments[i + 1]) != 'undefined') {
            this.items[arguments[i]] = arguments[i + 1];
            this.length++;
        }
    }

    this.removeItem = function (in_key) {
        var tmp_previous;
        if (typeof (this.items[in_key]) != 'undefined') {
            this.length--;
            var tmp_previous = this.items[in_key];
            delete this.items[in_key];
        }

        return tmp_previous;
    }

    this.getItem = function (in_key) {
        return this.items[in_key];
    }

    this.setItem = function (in_key, in_value) {
        var tmp_previous;
        if (typeof (in_value) != 'undefined') {
            if (typeof (this.items[in_key]) == 'undefined') {
                this.length++;
            } else {
                tmp_previous = this.items[in_key];
            }

            this.items[in_key] = in_value;
        }

        return tmp_previous;
    }

    this.hasItem = function (in_key) {
        return typeof (this.items[in_key]) != 'undefined';
    }

    this.clear = function () {
        for (var i in this.items) {
            delete this.items[i];
        }

        this.length = 0;
    }
}
Birey
la source
1
Pour les personnes qui ne votent pas, pouvez-vous expliquer pourquoi? Cette réponse a été publiée en 2011 et n'est pas à la date du jour.
Birey
2
Je n'ai pas voté contre, mais ... vous ne devriez pas utiliser un tableau comme objet. Pas sûr à 100% si c'était votre intention. Utilisez une tranche sur les tableaux non supprimés pour réindexer; la suppression est correcte mais sera définie sur undefined - mieux vaut être explicite; use = undefined sur un objet trop b / c c'est plus rapide (mais plus de mémoire). En bref: utilisez toujours un objet: {}pas un tableau: []ou new Array()si vous avez l'intention d'avoir des clés de chaîne sinon le moteur js a un problème - il verra soit 2 types pour 1 variable ce qui signifie aucune optimisation ou il fonctionnera avec un tableau et réalisera il doit changer d'objet (réallocation possible).
Graeme Wicksted du
2
Tout comme avec la réponse d'Alex Hawkins, veuillez expliquer pourquoi ce code d'aspect plutôt complexe est réellement utile et meilleur que les autres réponses plus courtes données ici.
Thomas Tempelmann
6

J'ai créé cela pour résoudre certains problèmes, tels que le mappage de clé d'objet, la capacité d'énumération (avec la forEach()méthode) et l'effacement.

function Hashtable() {
    this._map = new Map();
    this._indexes = new Map();
    this._keys = [];
    this._values = [];
    this.put = function(key, value) {
        var newKey = !this.containsKey(key);
        this._map.set(key, value);
        if (newKey) {
            this._indexes.set(key, this.length);
            this._keys.push(key);
            this._values.push(value);
        }
    };
    this.remove = function(key) {
        if (!this.containsKey(key))
            return;
        this._map.delete(key);
        var index = this._indexes.get(key);
        this._indexes.delete(key);
        this._keys.splice(index, 1);
        this._values.splice(index, 1);
    };
    this.indexOfKey = function(key) {
        return this._indexes.get(key);
    };
    this.indexOfValue = function(value) {
        return this._values.indexOf(value) != -1;
    };
    this.get = function(key) {
        return this._map.get(key);
    };
    this.entryAt = function(index) {
        var item = {};
        Object.defineProperty(item, "key", {
            value: this.keys[index],
            writable: false
        });
        Object.defineProperty(item, "value", {
            value: this.values[index],
            writable: false
        });
        return item;
    };
    this.clear = function() {
        var length = this.length;
        for (var i = 0; i < length; i++) {
            var key = this.keys[i];
            this._map.delete(key);
            this._indexes.delete(key);
        }
        this._keys.splice(0, length);
    };
    this.containsKey = function(key) {
        return this._map.has(key);
    };
    this.containsValue = function(value) {
        return this._values.indexOf(value) != -1;
    };
    this.forEach = function(iterator) {
        for (var i = 0; i < this.length; i++)
            iterator(this.keys[i], this.values[i], i);
    };
    Object.defineProperty(this, "length", {
        get: function() {
            return this._keys.length;
        }
    });
    Object.defineProperty(this, "keys", {
        get: function() {
            return this._keys;
        }
    });
    Object.defineProperty(this, "values", {
        get: function() {
            return this._values;
        }
    });
    Object.defineProperty(this, "entries", {
        get: function() {
            var entries = new Array(this.length);
            for (var i = 0; i < entries.length; i++)
                entries[i] = this.entryAt(i);
            return entries;
        }
    });
}


Documentation de la classe Hashtable

Méthodes:

  • get(key)
    Renvoie la valeur associée à la clé spécifiée.
    Paramètres::
    key clé à partir de laquelle récupérer la valeur.

  • put(key, value)
    Associe la valeur spécifiée à la clé spécifiée.
    Paramètres::
    key clé à laquelle associer la valeur.
    value: Valeur à associer à la clé.

  • remove(key)
    Supprime la clé spécifiée avec sa valeur.
    Paramètres::
    key la clé à supprimer.

  • clear()
    Efface toute la table de hachage, supprimant à la fois les clés et les valeurs.

  • indexOfKey(key)
    Renvoie l'index de la clé spécifiée, en fonction de l'ordre d'ajout.
    Paramètres:: dont
    key la clé obtient l'index.

  • indexOfValue(value)
    Renvoie l'index de la valeur spécifiée, en fonction de l'ordre d'ajout.
    Paramètres:: dont
    value la valeur obtient l'index.
    Notes:
    Ces informations sont récupérées par la indexOf()méthode d'un tableau, donc il compare l'objet juste avec la toString()méthode.

  • entryAt(index)
    Renvoie un objet avec deux propriétés: clé et valeur, représentant l'entrée à l'index spécifié.
    Paramètres::
    index L'index de l'entrée à obtenir.

  • containsKey(key)
    Renvoie si la table de hachage contient la clé spécifiée.
    Paramètres::
    key La clé à vérifier.

  • containsValue(value)
    Renvoie si la table de hachage contient la valeur spécifiée.
    Paramètres::
    value La valeur à vérifier.

  • forEach(iterator)
    Itère toutes les entrées dans le spécifié iterator.
    Paramètres:
    value : Procédé de 3 paramètres: key, valueet indexindexreprésente l'indice de l'entrée.

    Propriétés:

  • length ( Lecture seule )
    Obtient le nombre d'entrées dans la table de hachage.

  • keys ( Lecture seule )
    Obtient un tableau de toutes les clés de la table de hachage.

  • values ( Lecture seule )
    Obtient un tableau de toutes les valeurs de la table de hachage.

  • entries ( Lecture seule )
    Obtient un tableau de toutes les entrées de la table de hachage. Ils sont représentés sous la même forme que la méthode entryAt().

Davide Cannizzo
la source
2

https://gist.github.com/alexhawkins/f6329420f40e5cafa0a4

var HashTable = function() {
  this._storage = [];
  this._count = 0;
  this._limit = 8;
}


HashTable.prototype.insert = function(key, value) {
  //create an index for our storage location by passing it through our hashing function
  var index = this.hashFunc(key, this._limit);
  //retrieve the bucket at this particular index in our storage, if one exists
  //[[ [k,v], [k,v], [k,v] ] , [ [k,v], [k,v] ]  [ [k,v] ] ]
  var bucket = this._storage[index]
    //does a bucket exist or do we get undefined when trying to retrieve said index?
  if (!bucket) {
    //create the bucket
    var bucket = [];
    //insert the bucket into our hashTable
    this._storage[index] = bucket;
  }

  var override = false;
  //now iterate through our bucket to see if there are any conflicting
  //key value pairs within our bucket. If there are any, override them.
  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    if (tuple[0] === key) {
      //overide value stored at this key
      tuple[1] = value;
      override = true;
    }
  }

  if (!override) {
    //create a new tuple in our bucket
    //note that this could either be the new empty bucket we created above
    //or a bucket with other tupules with keys that are different than 
    //the key of the tuple we are inserting. These tupules are in the same
    //bucket because their keys all equate to the same numeric index when
    //passing through our hash function.
    bucket.push([key, value]);
    this._count++
      //now that we've added our new key/val pair to our storage
      //let's check to see if we need to resize our storage
      if (this._count > this._limit * 0.75) {
        this.resize(this._limit * 2);
      }
  }
  return this;
};


HashTable.prototype.remove = function(key) {
  var index = this.hashFunc(key, this._limit);
  var bucket = this._storage[index];
  if (!bucket) {
    return null;
  }
  //iterate over the bucket
  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    //check to see if key is inside bucket
    if (tuple[0] === key) {
      //if it is, get rid of this tuple
      bucket.splice(i, 1);
      this._count--;
      if (this._count < this._limit * 0.25) {
        this._resize(this._limit / 2);
      }
      return tuple[1];
    }
  }
};



HashTable.prototype.retrieve = function(key) {
  var index = this.hashFunc(key, this._limit);
  var bucket = this._storage[index];

  if (!bucket) {
    return null;
  }

  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    if (tuple[0] === key) {
      return tuple[1];
    }
  }

  return null;
};


HashTable.prototype.hashFunc = function(str, max) {
  var hash = 0;
  for (var i = 0; i < str.length; i++) {
    var letter = str[i];
    hash = (hash << 5) + letter.charCodeAt(0);
    hash = (hash & hash) % max;
  }
  return hash;
};


HashTable.prototype.resize = function(newLimit) {
  var oldStorage = this._storage;

  this._limit = newLimit;
  this._count = 0;
  this._storage = [];

  oldStorage.forEach(function(bucket) {
    if (!bucket) {
      return;
    }
    for (var i = 0; i < bucket.length; i++) {
      var tuple = bucket[i];
      this.insert(tuple[0], tuple[1]);
    }
  }.bind(this));
};


HashTable.prototype.retrieveAll = function() {
  console.log(this._storage);
  //console.log(this._limit);
};

/******************************TESTS*******************************/

var hashT = new HashTable();

hashT.insert('Alex Hawkins', '510-599-1930');
//hashT.retrieve();
//[ , , , [ [ 'Alex Hawkins', '510-599-1930' ] ] ]
hashT.insert('Boo Radley', '520-589-1970');
//hashT.retrieve();
//[ , [ [ 'Boo Radley', '520-589-1970' ] ], , [ [ 'Alex Hawkins', '510-599-1930' ] ] ]
hashT.insert('Vance Carter', '120-589-1970').insert('Rick Mires', '520-589-1970').insert('Tom Bradey', '520-589-1970').insert('Biff Tanin', '520-589-1970');
//hashT.retrieveAll();
/* 
[ ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Tom Bradey', '520-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Rick Mires', '520-589-1970' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '520-589-1970' ] ] ]
*/

//overide example (Phone Number Change)
//
hashT.insert('Rick Mires', '650-589-1970').insert('Tom Bradey', '818-589-1970').insert('Biff Tanin', '987-589-1970');
//hashT.retrieveAll();

/* 
[ ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Tom Bradey', '818-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Rick Mires', '650-589-1970' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]

*/

hashT.remove('Rick Mires');
hashT.remove('Tom Bradey');
//hashT.retrieveAll();

/* 
[ ,
  [ [ 'Boo Radley', '520-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]


*/

hashT.insert('Dick Mires', '650-589-1970').insert('Lam James', '818-589-1970').insert('Ricky Ticky Tavi', '987-589-1970');
hashT.retrieveAll();


/* NOTICE HOW HASH TABLE HAS NOW DOUBLED IN SIZE UPON REACHING 75% CAPACITY ie 6/8. It is now size 16.
 [,
  ,
  [ [ 'Vance Carter', '120-589-1970' ] ],
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Dick Mires', '650-589-1970' ],
    [ 'Lam James', '818-589-1970' ] ],
  ,
  ,
  ,
  ,
  ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Ricky Ticky Tavi', '987-589-1970' ] ],
  ,
  ,
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]




*/
console.log(hashT.retrieve('Lam James'));  //818-589-1970
console.log(hashT.retrieve('Dick Mires')); //650-589-1970
console.log(hashT.retrieve('Ricky Ticky Tavi')); //987-589-1970
console.log(hashT.retrieve('Alex Hawkins')); //510-599-1930
console.log(hashT.retrieve('Lebron James')); //null
Alex Hawkins
la source
3
À l'air cool. Maintenant, veuillez également expliquer POURQUOI cela est utile et peut être mieux adapté que toutes les autres réponses ici.
Thomas Tempelmann
1

Vous pouvez en créer un en utilisant comme suit:

var dictionary = { Name:"Some Programmer", Age:24, Job:"Writing Programs"  };

//Iterate Over using keys
for (var key in dictionary) {
  console.log("Key: " + key + " , " + "Value: "+ dictionary[key]);
}

//access a key using object notation:
console.log("Her Name is: " + dictionary.Name)

Ali Ezzat Odeh
la source