En javascript, quand utiliser l'objet littéral et quand utiliser array?

Question

Voici un exemple. Ma préoccupation est à la fois semblent faire le travail. lequel d'entre eux préférer?

var fooArr = [{ "bar": {"blah": 9 } }]; 

for(var i in fooArr) { 
    var value = fooArr[i].bar.blah; 
console.log(value); //checking in firebug console 
} 

var fooObj = { "bar": {"blah": 9 } }; 
for(var i in fooObj) { 
    var value = fooObj[i].blah; 
console.log(value); //checking in firebug console 
} 

De plus, ce qui suit semble ne pas être valide, Toute façon d'éviter la notation de tableau.

var fooObj1 = { 
    { "bar": { "blah": 9 } }, 
    { "bar": { "blah": 4 } }, 
    { "bar": { "blah":12} } 
}; 

J'ai donc dû modifier le code ci-dessus pour quelque chose comme ci-dessous qui fonctionne. Est-il trop trop mal pour être trop collant avec un objet littéraux

var fooObj1 = { 
    1:{ "bar": { "blah": 9 } }, 
    2:{ "bar": { "blah": 4 } }, 
    3:{ "bar": { "blah":12} } 
}; 

Merci encore et à l'avance à ceux qui me aider à la requête.

Answer 1

L'exemple ne compare pas vraiment les objets et les tableaux. Vous ajoutez simplement une couche inutile en plaçant un objet dans le premier élément d'un tableau.

Utilisez un objet lorsque vous devez vous référer à quelque chose par son nom.

var obj = {} 

// 3 façons de faire la même chose:

var obj.newName = 'bob'; 

var obj['newName'] = 'bob'; 

var name = 'newName'; 
var obj[name] = 'bob'; 

Le 2ème style est pas vraiment nécessaire et pourrait effectivement être une touche plus lente à l'accès que le 1er mais il vous aide à comprendre comment le 3ème peut être utile.Ou vous auriez pu faire ce qui suit pur et simple:

var obj = { newName:'bob' } 

Si vous voulez un tas de noms dans un objet, il obtiendrait un peu bête:

var obj = { newName:'bob', anotherNewName:'sue', yetAnotherNewName:'billy' } 

obj.newName === 'bob' 
obj.anotherNewName === 'sue' 
//etc... 

C'est ce que les tableaux sont pour.

var listOfNewNames = ['bob','sue','billy'] 
listOfNewNames[0] === 'bob' 
listOfNewNames[1] === 'sue' 
//etc... 

Bien sûr, rien ne vous empêche d'assigner un tableau à une propriété d'objet:

obj { listOfNewNames:['bob','sue','billy'] } 

obj.listOfNewNames[0] === 'bob' 

Ou, comme l'a démontré ci-dessus, plusieurs objets dans un tableau:

var listOfMonsters = [ 
    { monsterName:'Grarrr',eats:'people' }, 
    { monsterName:'Wadsworth',eats:'other monsters'} 
]; 

listOfMonsters[1].monsterName === 'Wadsworth' 

Les objets sont généralement plus sur le maintien de groupes de valeurs et de méthodes connexes pour faciliter la référence. Les tableaux ne sont qu'une liste de choses que l'on peut généralement supposer appliquer ou dériver de la même chose.

Answer 2

Utilisez un tableau lorsque vous savez que vous avez plus d'un objet. Un tableau d'un élément n'est pas nécessaire lorsqu'un seul objet sera utilisé. Comme vous pouvez le voir, la syntaxe est également un peu plus complexe (vous avez [...] et bar lorsque vous utilisez des tableaux -> plus de caractères sont utilisés), ne l'utilisez donc pas si vous n'en avez pas besoin.

Answer 3

Utilisez array si vous avez besoin de listes et utilisez des objets si vous avez besoin de propriétés.

Dans le cas ci-dessus, je préférerais le dernier.

En dehors de cela, ne jamais utiliser for in sur un tableau (il est extremely slow et des défaites dans le but) et toujours utiliser hasOwnProperty lorsque vous parcourez les propriétés d'un objet.

Answer 4

Vous utilisez un tableau lorsque vous devez utiliser plusieurs éléments. Exemple:

var fooArr = [{ bar: { blah: 9 } },{ bar: { blah: 4 } },{ bar: { blah: 12 } }]; 
for(var i in fooArr) { 
    var value = fooArr[i].bar.blah; 
    console.log(value); // will log "9", "4" and "12" 
} 

Dans le second exemple vous avez un seul objet, de sorte que vous n'avez pas besoin de la boucle du tout pour accéder à la propriété:

var fooObj = { bar: { blah: 9 } }; 
var value = fooObj.bar.blah; 
console.log(value); 

Answer 5

A itère boucle for .. in sur enumerables. Vous voudrez peut-être read up à ce sujet.

Si vous avez un tableau d'objets que je suggère une boucle for traditionnelle:

var fooObjs = [ {bar: "blah"}, {bar: "blah2"} ]; 
for (var i = 0, j = fooObj.length; i < j; i++) { 
    console.log(fooObjs[i].bar); 
} 

Si vous avez un objet avec des propriétés multiples, vous pouvez ensuite utiliser la boucle for .. in:

var fooObj = { bar: "blah", baz: "blah2" }; 
for (var i in fooObj) { 
    if (fooObj.hasOwnProperty(i)) { // So you don't log prototype properties 
    console.log(fooObj[i]); 
    } 
}