Nome da propriedade do object como número

De acordo com a documentação oficial do JavaScript, você pode definir nomes de propriedades literais de objects usando inteiros:

Além disso, você pode usar um literal numérico ou string para o nome de uma propriedade.

Igual a:

me = { name: "Robert Rocha", 123: 26, origin: "Mexico" } 

Minha pergunta é, como você faz referência à propriedade que tem um número inteiro como um nome? Eu tentei o habitual me.123 mas recebi um erro. A única solução que posso pensar é usando um loop for-in . Alguma sugestão?

Você pode referenciar as propriedades do object como se fosse um array e usar me[123] ou me["123"]

A notação de pontos só funciona com nomes de propriedades que são identificadores válidos. Um identificador deve começar com uma seqüência de escape letter, $, _ ou unicode. Para todos os outros nomes de propriedade, você deve usar a notação de colchetes.

Em um literal de object, o nome da propriedade deve ser um nome de identificador, literal de string ou literal numérico (que será convertido em uma string, pois os nomes das propriedades devem ser strings):

 var obj = {1:1, foo:'foo', '+=+':'+=+'}; alert(obj[1] + ' ' + obj.foo + ' ' + obj['+=+']); // 1 foo +=+ 

Você pode me[123] usar me[123] ou me["123"] . Ambos funcionam.

Você pode usar a notação de colchetes me[123] .

Apenas no caso de alguém mais ficar confuso com isso: usar nomes de propriedades inteiros (em vez de string) pode dar resultados ligeiramente diferentes – embora funcionalmente iguais – (dependendo do navegador) quando você tem objects dentro de objects.

Objetos simples sem objects nesteds têm comportamento consistente em todos os navegadores (embora, como diz a resposta aceita , precisamos usar colchetes em vez de pontos para acessar nomes de propriedades inteiras):

 var str_simple = { a: "b", c: "d", e: "f", g: "h", }; str_simple.a === "b"; // true str_simple.e === "f"; // true var int_simple = { 1: 2, 3: 4, 5: 6, 7: 8, }; int_simple[1] === 2; // true - must use brackets instead of dots int_simple[5] === 6; // true // this works b/c int property names are coerced to strings anyway int_simple[1] === int_simple['1']; // true 

E esse object nested com chaves de string funciona exatamente como esperado:

 var str_nested = { a: {b: "c"}, d: {e: "f", g: "h"}, }; str_nested.a; // returns object as expected, no matter the browser - {b: "c"} str_nested.ab === "c"; // true str_nested.dg === "h"; // true 

Mas este object nested equivalente com chaves inteiras retorna resultados ligeiramente diferentes dependendo do navegador, embora você ainda possa acessar os objects nesteds da mesma maneira (então, funcionalmente, ele ainda funciona da mesma forma):

 var int_nested = { 1: {2: 3}, 4: {5: 6, 7: 8}, }; // latest Chrome (57) // Safari 10 (latest for my Mac, 10.10 Yosemite) int_nested[1]; // returns object as expected - {2: 3} int_nested[1][2] === 3; // true // latest Firefox (52) int_nested[1]; // RETURNS ARRAY-LIKE OBJECT - Object [ <2 empty slots>, 3 ] int_nested.length; // undefined because it's not technically an array int_nested[1][2] === 3; // true - works b/c object was padded with empty slots // and again, in all browsers, we can exchange the integer keys // for equivalent strings since property names are coerced to strings anyway int_nested[1][2] === int_nested['1'][2]; int_nested['1'][2] === int_nested[1]['2']; int_nested[1]['2'] === int_nested['1']['2']; 

Esse comportamento ainda será um pouco diferente, mas funcionalmente o mesmo se você programaticamente construir um object nested. Por exemplo, digamos que queremos escrever uma function que leve uma lista de pares (por exemplo, [[0, 0], [0, 1], [1, 2], [2, 3]] ) e converta-a em um object nested para que pudéssemos verificar se o par está no object com tempo O (1) (por exemplo, {0: {0: true, 1: true}, 1: {2: true}, 2: {3, true}} ). Note que os Sets verificam a igualdade de referência e não o valor de igualdade , então não podemos armazenar o par em si no Set e obter os mesmos resultados:

 // [[0, 0], [0, 1], [1, 2], [2, 3]] -> // { // 0: {0: true, 1: true}, // 1: {2: true}, // 2: {3: true}, // } function createNestedObject(pairs) { var obj = {}; for (var pair of pairs) { var x = pair[0], y = pair[1]; // must create outer object for each unique x or else // obj[x][y] would fail b/c obj[x] would be undefined if (!obj.hasOwnProperty(x)) { obj[x] = {}; } obj[x][y] = true; } return obj; } function exists(nested, pair) { var x = pair[0], y = pair[1]; // uses !! operator so if pair isn't in nested // we return false instead of undefined return !!(nested[x] && nested[x][y]); } 

Pares com strings funcionarão como esperado:

 var pairs = [["a", "a"], ["a", "b"], ["c", "d"], ["d", "e"]]; var nested = createNestedObject(pairs); nested; // as expected - {a: {a: true, b: true}, c: {d: true}, d: {e: true}} exists(nested, ["a", "a"]); // true exists(nested, ["a", "b"]); // true exists(nested, ["ZZZ", "ZZZ"]); // false 

Mas em certos navegadores, pares inteiros serão diferentes, mas funcionalmente iguais:

 var pairs = [[0, 0], [0, 1], [1, 2], [2, 3]]; var nested = createNestedObject(pairs); nested; // in Safari 10/Chrome 57 - returns nested objects as expected nested; // in Firefox 52 - Object [ Object[2], Object[3], Object[4] ] // BUT still gives correct results no matter the browser exists(nested, [0, 0]); // true exists(nested, [0, 1]); // true exists(nested, ['0', '0']); // true exists(nested, [999, 999]); // false 

A situação com nomes de propriedades numéricas parece mais complicada do que é explicada nas respostas até agora. É verdade que você pode acessar tais propriedades via loop for-in. No entanto, pode ser importante saber que o loop for-in fornece chaves como cadeias, não como números como seria de esperar:

 var obj = {1:2}; for (var key in obj) { alert(typeof(obj[key])); // you get "number" as expected, however alert(typeof(key)); // you get "string", not "number" } 

Algo semelhante acontece durante a serialização com o JSON:

 JSON.stringify( {1:2} ) === '{"1":2}' 

Então, se você codifica depende desse pequeno detalhe, é melhor estar ciente disso.