Имя свойства объекта как число

Ответ 1

Вы можете ссылаться на свойства объекта, как на массив, и использовать либо me[123], либо me["123"]

Ответ 2

Точечная нотация работает только с именами свойств, которые являются действительными идентификаторами. Идентификатор должен начинаться с escape-последовательности букв, $, _ или unicode. Для всех других имен свойств вы должны использовать нотацию в виде скобок.

В литературе объекта имя свойства должно быть именем идентификатора, строковым литералом или числовым литералом (который будет преобразован в строку, поскольку имена свойств должны быть строками):

var obj = {1:1, foo:'foo', '+=+':'+=+'};

alert(obj[1] + ' ' + obj.foo + ' ' + obj['+=+']); // 1 foo +=+

Ответ 3

Вы можете использовать me[123] или me["123"]. Оба работают.

Ответ 4

Вы можете использовать обозначение скобок me[123].

Ответ 5

На всякий случай кто-то был смущен этим: использование имен свойств integer (а не string) может дать немного другое - хотя функционально то же самое - результаты (в зависимости от браузера), когда у вас есть объекты внутри объектов.

Простые объекты без вложенных объектов имеют последовательное поведение в браузерах (хотя как говорится в принятом ответе, нам нужно использовать скобки вместо точек для доступа к именам свойств целого)

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

И этот вложенный объект со строковыми клавишами работает точно так, как ожидалось:

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

Но этот эквивалентный вложенный объект с целыми ключами возвращает несколько разные результаты в зависимости от браузера, хотя вы все равно можете обращаться к вложенным объектам одинаково (так функционально, он все равно работает одинаково):

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

Это поведение по-прежнему будет немного отличаться, но функционально одинаково, если вы программно создадите вложенный объект. Например, предположим, что мы хотели написать функцию, которая возьмет список пар (например, [[0, 0], [0, 1], [1, 2], [2, 3]]) и преобразует ее во вложенный объект, чтобы мы могли проверить, находится ли пара в объекте с временем O (1) (например, {0: {0: true, 1: true}, 1: {2: true}, 2: {3, true}}). Обратите внимание, что Устанавливает проверку равенства ссылок, а не равенства значений, поэтому мы не смогли сохраните пару в наборе и получите те же результаты:

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

Пары со строками будут работать как ожидалось:

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

Но в некоторых браузерах целые пары будут разными, но функционально одинаковыми:

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

Ответ 6

Ситуация с числовыми именами свойств кажется более сложной, чем объясняется в ответах до сих пор. Это правда, что вы можете получить доступ к таким свойствам через цикл for-in. Тем не менее, может быть важно знать, что цикл for-in предоставляет ключи как строки, а не как числа, которые вы могли бы ожидать:

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

Аналогичная ситуация наблюдается при сериализации с JSON:

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

Итак, если код зависит от этой маленькой детали, вам лучше знать об этом.