array - javascript object properties

Nombre de la propiedad del objeto como número

Question

De acuerdo con la documentación oficial de JavaScript , puede definir nombres de propiedades literales de objetos usando enteros:

Además, puede usar un literal numérico o de cadena para el nombre de una propiedad.

Al igual que:

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

Mi pregunta es, ¿cómo hace referencia a la propiedad que tiene un número entero como nombre? me.123 el usual me.123 pero obtuve un error. La única solución que puedo pensar es usar un bucle for-in . ¿Alguna sugerencia?

Answer 1

En caso de que alguien más esté confundido por esto: el uso de enteros (en lugar de cadenas) los nombres de propiedad pueden dar resultados ligeramente diferentes (aunque funcionalmente iguales) (dependiendo del navegador) cuando tienes objetos dentro de los objetos.

Los objetos simples sin objetos anidados tienen un comportamiento consistente en todos los navegadores (aunque, como dice la respuesta aceptada , necesitamos usar corchetes en lugar de puntos para acceder a nombres de propiedades enteros):

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

Y este objeto anidado con claves de cadena funciona exactamente como se esperaba:

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.a.b === "c"; // true
str_nested.d.g === "h"; // true

Pero este objeto anidado equivalente con claves enteras arroja resultados ligeramente diferentes dependiendo del navegador, aunque aún puede acceder a los objetos anidados de la misma manera (por lo que funcionalmente, sigue funcionando igual):

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''];

Este comportamiento aún será ligeramente diferente pero funcionalmente igual si construye un objeto anidado mediante programación. Por ejemplo, digamos que queríamos escribir una función que tomaría una lista de pares (por ejemplo, [[0, 0], [0, 1], [1, 2], [2, 3]] ) y la convertiría en una Objeto anidado para que podamos verificar si el par está en el objeto con O (1) tiempo (ej. {0: {0: true, 1: true}, 1: {2: true}, 2: {3, true}} ) Tenga en cuenta que Sets igualdad de referencia de comprobación y no la igualdad de valores , por lo que no podríamos almacenar el par en el Conjunto y lograr los mismos 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]);
}

Los pares con cadenas funcionarán como se espera:

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

Pero en ciertos navegadores, los pares enteros serán diferentes pero funcionalmente iguales:

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

Answer 2

La notación de puntos solo funciona con nombres de propiedad que son identificadores válidos. Un identificador debe comenzar con una secuencia de escape de letra, $, _ o unicode. Para todos los demás nombres de propiedad, debe usar la notación de corchetes.

En un literal de objeto, el nombre de propiedad debe ser un nombre de identificador, cadena literal o literal numérico (que se convertirá en una cadena ya que los nombres de propiedad deben ser cadenas):

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

Answer 3

La situación con los nombres de propiedades numéricas parece más complicada de lo que se explica en las respuestas hasta ahora. Es cierto que puede acceder a dichas propiedades a través del bucle for-in. Sin embargo, podría ser importante saber que for-in loop da claves como cadenas, no como números como cabría 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 similar ocurre durante la serialización con JSON:

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

Entonces, si el código depende de este pequeño detalle, es mejor que lo tenga en cuenta.

Answer 4

Puede me[123] o me["123"] . Ambos trabajan.

Answer 5

Puede hacer referencia a las propiedades del objeto como lo haría con una matriz y usar me[123] o me["123"]

Answer 6

Puede usar la notación de corchete me[123] .