In javascript, quando usare oggetto letterale e quando utilizzare array?

Question

Ecco un esempio. La mia preoccupazione è entrambi sembrano fare il lavoro. chi di loro a preferire?

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
}

Inoltre, il seguente sembra essere non valido, qualsiasi modo per evitare la notazione di matrice.

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

Così ho dovuto modificare il codice di cui sopra a qualcosa di simile sotto del quale le opere. E 'troppo troppo brutto per essere troppo appiccicoso con letterali oggetto

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

Grazie ancora e in anticipo a chi mi aiutano con la query.

Answer 1

Il campione non confrontare in realtà gli oggetti e gli array. Stai solo l'aggiunta di uno strato inutile mettendo un oggetto nel primo elemento di un array.

Usa un oggetto quando si deve fare riferimento a qualcosa per nome.

var obj = {}

// 3 modi di fare la stessa cosa:

var obj.newName = 'bob';

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

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

Il secondo stile non è realmente necessario e potrebbe in realtà essere un tocco lento di accesso rispetto alla prima, ma aiuta a capire come il 3 ° può essere utile. Oppure si potrebbe aver fatto il seguente titolo definitivo:

var obj = { newName:'bob' }

Se si vuole un po 'di nomi in un oggetto, si otterrebbe un po' sciocco:

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

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

Questo è ciò che gli array sono per.

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

Naturalmente, nulla vieta di assegnare una matrice di proprietà di un oggetto:

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

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

O, come dimostrato sopra, più oggetti in un array:

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

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

Gli oggetti sono tipicamente più circa mantenere gruppi di valori e relativi metodi insieme per facilità di riferimento. Gli array sono solo un elenco di cose che tutti in genere può essere assunto da applicare o derivano dalla stessa cosa.

Answer 2

Un ciclo for .. in itera su enumerables. Si potrebbe desiderare di leggere su di esso .

Se si dispone di un array di oggetti Vorrei suggerire un ciclo for tradizionale:

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

Se si dispone di un oggetto con più proprietà, allora si potrebbe utilizzare il ciclo 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]);
  }
}

Answer 3

Utilizzare una matrice quando sai che avrai più di un oggetto. Una matrice un elemento non è necessario quando viene utilizzato un solo oggetto.

Come si può vedere, la sintassi è anche un po 'più complesso (avete [...] e bar quando si utilizzano gli array -> più caratteri vengono utilizzati), in modo da non utilizzarlo se non è necessario

Answer 4

Usa array se avete bisogno di liste e utilizzare gli oggetti se avete bisogno di proprietà.

Nel caso di cui sopra, io preferirei la seconda uno.

A parte questo, non usare mai for in su un array (è estremamente lento e vanifica il senso) e utilizzare sempre hasOwnProperty quando l'iterazione più di proprietà di un oggetto.

Answer 5

Si utilizza una matrice quando è necessario utilizzare più di un elemento. Esempio:

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"
}

Nel secondo esempio si hanno solo un singolo oggetto, quindi non è necessario il circuito a tutti di accedere alla proprietà:

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