javascript array associatif ET indexé?

Il n'y a pas de telles choses comme des tableaux associatifs en Javascript. Vous pouvez utiliser des objets littéraux, qui look comme des tableaux associatifs, mais ils ont des propriétés non ordonnée. Régulièrement les tableaux Javascript sont basés sur les index entiers, et ne peut pas être associative.

Par exemple, avec cet objet:

var params = {
    foo: 1,
    bar: 0,
    other: 2
};

Vous pouvez accéder aux propriétés de l'objet, par exemple:

params["foo"];

Et vous pouvez également effectuer une itération sur l'objet à l'aide de la for...in déclaration:

for(var v in params) {
    //v is equal to the currently iterated property
}

Cependant, il n'existe pas de règle stricte de l'ordre de la propriété d'itération - deux itérations de votre objet littéral pourrait renvoyer les propriétés dans des ordres différents.

Natif d'objets JS acceptons uniquement les chaînes que les noms de propriété, ce qui est vrai même pour les indices de tableau; les tableaux diffèrent de la vanille, des objets uniquement dans la mesure où la plupart des JS implémentations magasin indexé numériquement les propriétés différemment (c'est à dire dans un tableau réel, aussi longtemps qu'ils sont denses), et de déclencher des opérations supplémentaires (par exemple, le réglage de la length propriété).

Si vous êtes à la recherche d'une carte qui accepte les clés arbitraires, vous aurez à utiliser un non-natifs de la mise en œuvre. Le script est prévu pour l'itération rapide et pas d'accès aléatoire par des indices numériques, de sorte qu'il pourrait ni être ce que vous cherchez.

Un barebones la mise en œuvre d'un plan qui permettrait de faire ce que vous proposez pourrait ressembler à ceci:

function Map() {
    this.length = 0;
    this.store = {};
}

Map.prototype.get = function(key) {
    return this.store.hasOwnProperty(key) ?
        this.store[key] : undefined;
};

Map.prototype.put = function(key, value, index) {
    if(arguments.length < 3) {
        if(this.store.hasOwnProperty(key)) {
            this.store[key].value = value;
            return this;
        }

        index = this.length;
    }
    else if(index >>> 0 !== index || index >= 0xffffffff)
        throw new Error('illegal index argument');

    if(index >= this.length)
        this.length = index + 1;

    this[index] = this.store[key] =
        { index : index, key : key, value : value };

    return this;
};

La index argument de put() est facultatif.

Vous pouvez accéder aux valeurs dans une carte map soit par clé ou l'indice de via

map.get('key').value
map[2].value

var myArray = Array();
myArray["first"] = "Object1";
myArray["second"] = "Object2";
myArray["third"] = "Object3";

Object.keys(myArray);              //returns ["first", "second", "third"]
Object.keys(myArray).length;       //returns 3

si vous souhaitez que le premier élément, alors vous pouvez l'utiliser comme ceci:

myArray[Object.keys(myArray)[0]];  //returns "Object1"

Je suis venu ici à vouloir savoir si c'est une mauvaise pratique ou pas, et au lieu trouvé beaucoup de personnes qui comparaissent pas à comprendre la question.

Je voulais avoir une structure de données qui a été ordonnée, mais pourrait être indexé par la clé, de sorte qu'elle ne nécessite pas d'itération pour chaque recherche.

En termes pratiques, cela est assez simple, mais je n'ai toujours pas lu quelque chose sur si c'est une terrible pratique ou pas.

var roygbiv = [];
var colour = { key : "red", hex : "#FF0000" };
roygbiv.push(colour);
roygbiv[colour.key] = colour;
...
console.log("Hex colours of the rainbow in order:");
for (var i = 0; i < roygbiv.length; i++) {
    console.log(roygbiv[i].key + " is " + roygbiv[i].hex);
}

//input = "red";
console.log("Hex code of input colour:");
console.log(roygbiv[input].hex);

La chose importante est de ne jamais modifier la valeur de tableau[index] ou tableau[key] directement une fois que l'objet ou les valeurs ne correspondent plus. Si le tableau contient des objets vous pouvez modifier les propriétés de ces objets et vous serez en mesure d'accéder à la modification des propriétés par la méthode.

La marée a changé sur ce point. Maintenant, vous pouvez faire cela... et PLUS encore! À l'aide de l'Harmonie proxy vous peut certainement résoudre ce problème de plusieurs façons.

Vous aurez à vérifier que vos environnements ciblés charge ce avec peut-être un peu d'aide de la harmonie-réfléchir cale.

Il y a un très bon exemple sur le Mozilla Developer Network sur l'utilisation d'un Proxy pour trouver un élément de tableau d'objets, de par leur propriété qui assez bien, il résume.

Voici ma version:

  var players = new Proxy(
[{
name: 'monkey',
score: 50
}, {
name: 'giraffe',
score: 100
}, {
name: 'pelican',
score: 150
}], {
get: function(obj, prop) {
if (prop in obj) {
//default behavior
return obj[prop];
}
if (typeof prop == 'string') {
if (prop == 'rank') {
return obj.sort(function(a, b) {
return a.score > b.score ? -1 : 1;
});
}
if (prop == 'revrank') {
return obj.sort(function(a, b) {
return a.score < b.score ? -1 : 1;
});
}
var winner;
var score = 0;
for (var i = 0; i < obj.length; i++) {
var player = obj[i];
if (player.name == prop) {
return player;
} else if (player.score > score) {
score = player.score;
winner = player;
}
}
if (prop == 'winner') {
return winner;
}
return;
}
}
});
console.log(players[0]); //{ name: 'monkey', score: 50 }
console.log(players['monkey']); //{ name: 'monkey', score: 50 }
console.log(players['zebra']); //undefined
console.log(players.rank); //[ { name: 'pelican', score: 150 },{ name: 'giraffe', score: 100 }, { name: 'monkey', score: 50 } ]
console.log(players.revrank); //[ { name: 'monkey', score: 50 },{ name: 'giraffe', score: 100 },{ name: 'pelican', score: 150 } ]
console.log(players.winner); //{ name: 'pelican', score: 150 }