Usando um inteiro como uma chave em uma matriz associativa em JavaScript

Quando eu crio um novo array JavaScript e uso um inteiro como chave, cada elemento desse array até o inteiro é criado como indefinido.

Por exemplo:

var test = new Array();
test[2300] = 'Some string';
console.log(test);

irá imprimir 2298 undefined's e um 'Some string'.

Como devo fazer com que o JavaScript use 2300 como uma string em vez de um inteiro, ou como devo evitar que instancie 2299 índices vazios?

Use um objeto, como as pessoas estão dizendo. No entanto, observe que você não pode ter chaves inteiras. JavaScript irá converter o inteiro em uma string . Os seguintes resultados são 20, não indefinidos:

var test = {}
test[2300] = 20;
console.log(test["2300"]);

Você pode apenas usar um objeto:

var test = {}
test[2300] = 'Some string';

Como as pessoas dizem, o JavaScript irá converter uma string de número em inteiro, então não é possível usar diretamente em uma matriz associativa, mas os objetos funcionarão para você de maneira semelhante, eu acho.

Você pode criar seu objeto:

var object = {};

E adicione os valores conforme a matriz funciona:

object[1] = value;
object[2] = value;

Isso lhe dará:

{
  '1': value,
  '2': value
}

Depois disso, você pode acessá-lo como um array em outras línguas obtendo a chave:

for(key in object)
{
   value = object[key] ;
}

Eu testei e funciona.

Se o caso de uso estiver armazenando dados em uma coleção, o ECMAScript 6 fornece o Maptipo.

É apenas mais pesado para inicializar.

Aqui está um exemplo:

const map = new Map();
map.set(1, "One");
map.set(2, "Two");
map.set(3, "Three");

console.log("=== With Map ===");

for (const [key, value] of map) {
    console.log(`${key}: ${value} (${typeof(key)})`);
}

console.log("=== With Object ===");

const fakeMap = {
    1: "One",
    2: "Two",
    3: "Three"
};

for (const key in fakeMap) {
    console.log(`${key}: ${fakeMap[key]} (${typeof(key)})`);
}

Resultado:

=== With Map ===
1: One (number)
2: Two (number)
3: Three (number)
=== With Object ===
1: One (string)
2: Two (string)
3: Three (string)

Compilando outras respostas:

Objeto

var test = {};

Ao usar um número como a chave de uma nova propriedade, o número se transforma em uma string:

test[2300] = 'Some string';
console.log(test['2300']);
// Output: 'Some string'

Ao acessar o valor da propriedade usando o mesmo número, o número é transformado em string novamente:

console.log(test[2300]);
// Output: 'Some string'

Ao obter as chaves do objeto, no entanto, elas não serão transformadas em números:

for (var key in test) {
    console.log(typeof key);
}
// Output: 'string'

Mapa

ECMAScript 6 permite o uso do objeto Map ( documentação , uma comparação com Object ). Se seu código deve ser interpretado localmente ou se a tabela de compatibilidade ECMAScript 6 parece verde o suficiente para seus objetivos, considere o uso de um mapa:

var test = new Map();
test.set(2300, 'Some string');
console.log(test.get(2300));
// Output: 'Some string'

Nenhuma conversão de tipo é realizada, para o melhor ou para o pior:

console.log(test.get('2300'));
// Output: undefined
test.set('2300', 'Very different string');
console.log(test.get(2300));
// Output: 'Some string'

Use um objeto em vez de uma matriz. Arrays em JavaScript não são arrays associativos. Eles são objetos com magia associada a quaisquer propriedades cujos nomes pareçam inteiros. Essa mágica não é o que você deseja se não os estiver usando como uma estrutura tradicional semelhante a um array.

var test = {};
test[2300] = 'some string';
console.log(test);

Tente usar um objeto, não um array:

var test = new Object(); test[2300] = 'Some string';

Obtenha o valor de uma propriedade de matriz associativa quando o nome da propriedade for um inteiro:

Começando com uma matriz associativa em que os nomes das propriedades são inteiros:

var categories = [
    {"1": "Category 1"},
    {"2": "Category 2"},
    {"3": "Category 3"},
    {"4": "Category 4"}
];

Envie itens para a matriz:

categories.push({"2300": "Category 2300"});
categories.push({"2301": "Category 2301"});

Faça um loop pela matriz e faça algo com o valor da propriedade.

for (var i = 0; i < categories.length; i++) {
    for (var categoryid in categories[i]) {
        var category = categories[i][categoryid];
        // Log progress to the console
        console.log(categoryid + ": " + category);
        //  ... do something
    }
}

A saída do console deve ser assim:

1: Category 1
2: Category 2
3: Category 3
4: Category 4
2300: Category 2300
2301: Category 2301

Como você pode ver, você pode contornar a limitação da matriz associativa e ter um nome de propriedade um inteiro.

NOTA: O array associativo em meu exemplo é o conteúdo JSON que você teria se serializasse um objeto Dictionary <string, string> [].

Use um objeto - com um inteiro como chave - em vez de uma matriz.

Às vezes eu uso prefixos para minhas chaves. Por exemplo:

var pre = 'foo',
    key = pre + 1234

obj = {};

obj[key] = val;

Agora você não tem nenhum problema para acessá-los.