Nom de propriété d'objet que le nombre

Vous pouvez référencer les propriétés de l'objet, comme vous le feriez d'un tableau et d'utiliser soit me[123] ou me["123"]

Vous pouvez utiliser me[123] ou me["123"]. Les deux travaux.

Juste au cas où quelqu'un d'autre a été confondu par ce: à l'aide d'entiers (plutôt que de la chaîne) les noms de propriété peut donner un peu différents, bien que fonctionnellement le même résultats (selon le navigateur) lorsque vous avez des objets à l'intérieur des objets.

Des objets simples avec aucun des objets imbriqués ont un comportement cohérent sur tous les navigateurs (même si que l'on a accepté la réponse dit, nous avons besoin d'utiliser des crochets à la place des points d'accès entier les noms de propriété):

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

Et cet objet imbriqué avec des clés de chaîne fonctionne exactement comme prévu:

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

Mais c'est l'équivalent de l'objet imbriqué avec entier touches renvoie des résultats légèrement différents selon le navigateur, mais vous pouvez toujours accéder aux objets imbriqués de la même façon (donc fonctionnellement, il fonctionne toujours de la même façon):

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

Ce comportement sera toujours légèrement différentes, mais le point de vue fonctionnel, même si par programmation de la construction d'un objet imbriqué. Par exemple, supposons que nous voulions écrire une fonction qui prendrait une liste de paires (par exemple [[0, 0], [0, 1], [1, 2], [2, 3]]) et de le convertir en un objet imbriqué nous avons donc pu vérifier si la paire est dans l'objet, avec O(1) temps (par exemple,{0: {0: true, 1: true}, 1: {2: true}, 2: {3, true}}). Notez que Jeux vérifier référence de l'égalité et de la non valeur de l'égalité, donc nous ne pouvions pas stocker la paire lui-même dans l'Ensemble et obtenir les mêmes résultats:

//[[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]);
}

Paires avec des chaînes fonctionnent comme prévu:

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

Mais dans certains navigateurs, entier paires seront différents, mais fonctionnellement le même:

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