La création dynamique de clés en JavaScript tableau associatif

En quelque sorte tous les exemples, tandis que bien, sont extrêmement compliquées:

• Ils utilisent new Array(), ce qui est inutile (et un rétroprojecteur) pour un simple tableau associatif (AKA dictionnaire).
• La meilleure utilisation new Object(). Fonctionne très bien, mais pourquoi toute cette saisie de texte supplémentaire?

Cette question est taggés "débutant", donc, nous allons faire simple.

L'uber-façon simple d'utiliser un dictionnaire en JavaScript ou "Pourquoi JavaScript n'est pas un spécial dictionnaire de l'objet?":

//create an empty associative array (in JavaScript it is called ... Object)
var dict = {};   //huh? {} is a shortcut for "new Object()"

//add a key named fred with value 42
dict.fred = 42;  //we can do that because "fred" is a constant
                 //and conforms to id rules

//add a key named 2bob2 with value "twins!"
dict["2bob2"] = "twins!";  //we use the subscript notation because
                           //the key is arbitrary (not id)

//add an arbitrary dynamic key with a dynamic value
var key = ..., //insanely complex calculations for the key
    val = ...; //insanely complex calculations for the value
dict[key] = val;

//read value of "fred"
val = dict.fred;

//read value of 2bob2
val = dict["2bob2"];

//read value of our cool secret key
val = dict[key];

Maintenant, nous allons changer les valeurs:

//change the value of fred
dict.fred = "astra";
//the assignment creates and/or replaces key-value pairs

//change value of 2bob2
dict["2bob2"] = [1, 2, 3];  //any legal value can be used

//change value of our secret key
dict[key] = undefined;
//contrary to popular beliefs assigning "undefined" does not remove the key

//go over all keys and values in our dictionary
for (key in dict) {
  //for-in loop goes over all properties including inherited properties
  //let's use only our own properties
  if (dict.hasOwnProperty(key)) {
    console.log("key = " + key + ", value = " + dict[key]);
  }
}

La suppression de valeurs est trop facile:

//let's delete fred
delete dict.fred;
//fred is removed, the rest is still intact

//let's delete 2bob2
delete dict["2bob2"];

//let's delete our secret key
delete dict[key];

//now dict is empty

//let's replace it, recreating all original data
dict = {
  fred:    42,
  "2bob2": "twins!"
  //we can't add the original secret key because it was dynamic,
  //we can only add static keys
  //...
  //oh well
  temp1:   val
};
//let's rename temp1 into our secret key:
if (key != "temp1") {
  dict[key] = dict.temp1; //copy the value
  delete dict.temp1;      //kill the old key
} else {
  //do nothing, we are good ;-)
}

En réponse à MK_Dev, on est capable de réitérer, mais pas consécutivement. (Pour que, évidemment, un tableau est nécessaire)

Rapide recherche sur google apporte les tables de hachage en javascript

Exemple de code pour faire une boucle sur les valeurs dans une table de hachage (à partir du lien ci-dessus):

var myArray = new Array();
myArray['one'] = 1;
myArray['two'] = 2;
myArray['three'] = 3;

//show the values stored
for (var i in myArray) {
    alert('key is: ' + i + ', value is: ' + myArray[i]);
}

Tous les navigateurs modernes soutenir un Carte, qui est une des clés/données de la valeur de la sténose. Il ya un couple de raisons qui font à l'aide d'une Carte de mieux que de l'Objet:

• Un Objet a un prototype, donc il y a des touches par défaut dans la carte.
• Les clés d'un Objet sont des Chaînes de caractères, où ils peuvent être n'importe quelle valeur pour une Carte.
• Vous pouvez obtenir la taille d'une Carte facilement alors que vous devez garder 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 voulez clés qui ne sont pas référencées à partir d'autres objets à ordures, pensez à utiliser un WeakMap au lieu de une Carte.

var myArray = new Array();
myArray['one'] = 1;
myArray['two'] = 2;
myArray['three'] = 3;

//show the values stored
for (var i in myArray) {
    alert('key is: ' + i + ', value is: ' + myArray[i]);
}

c'est ok, mais parcourt toutes les propriétés de l'objet array.
si vous voulez seulement de parcourir les propriétés myArray.l'un, myArray.deux... vous essayez comme ceci

myArray['one'] = 1;
myArray['two'] = 2;
myArray['three'] = 3;
myArray.push("one");
myArray.push("two");
myArray.push("three");
for(i=0;i<maArray.length;i++{
    console.log(myArray[myArray[i]])
}

maintenant, vous pouvez accéder à la fois par montableau["un"] et de réitérer que grâce à ces propriétés.