Utilizzo di un numero intero come chiave in un array associativo in JavaScript

Quando creo un nuovo array JavaScript e utilizzo un numero intero come chiave, ogni elemento di quell'array fino all'intero viene creato come non definito.

Per esempio:

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

produrrà 2298 undefined e una "Some string".

Come dovrei fare in modo che JavaScript utilizzi 2300 come stringa invece di un numero intero, o come dovrei impedire che istanziasse 2299 indici vuoti?

Usa un oggetto, come dicono le persone. Tuttavia, nota che si può non avere integer chiavi. JavaScript convertirà l'intero in una stringa . Le seguenti uscite 20, non indefinite:

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

Puoi semplicemente usare un oggetto:

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

Come si dice, JavaScript convertirà una stringa di numeri in un numero intero, quindi non è possibile utilizzarlo direttamente su un array associativo, ma penso che gli oggetti funzioneranno in modo simile.

Puoi creare il tuo oggetto:

var object = {};

E aggiungi i valori mentre l'array funziona:

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

Questo ti darà:

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

Dopodiché puoi accedervi come un array in altre lingue ottenendo la chiave:

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

Ho provato e funziona.

Se il caso d'uso è l'archiviazione dei dati in una raccolta, ECMAScript 6 fornisce il Maptipo.

È solo più pesante da inizializzare.

Ecco un esempio:

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)})`);
}

Risultato:

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

Compilare altre risposte:

Oggetto

var test = {};

Quando si utilizza un numero come chiave di una nuova proprietà, il numero si trasforma in una stringa:

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

Quando si accede al valore della proprietà utilizzando lo stesso numero, il numero viene nuovamente trasformato in una stringa:

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

Quando si ottengono le chiavi dall'oggetto, tuttavia, non verranno trasformate di nuovo in numeri:

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

Carta geografica

ECMAScript 6 consente l'utilizzo dell'oggetto Map ( documentazione , confronto con Object ). Se il tuo codice deve essere interpretato localmente o la tabella di compatibilità ECMAScript 6 sembra abbastanza verde per i tuoi scopi, considera l'utilizzo di una mappa:

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

Non viene eseguita alcuna conversione di tipo, nel bene e nel male:

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

Usa un oggetto invece di un array. Gli array in JavaScript non sono array associativi. Sono oggetti con la magia associata a qualsiasi proprietà i cui nomi sembrano numeri interi. Quella magia non è quello che vuoi se non li stai usando come una tradizionale struttura a matrice.

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

Prova a utilizzare un oggetto, non un array:

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

Ottieni il valore per una proprietà di matrice associativa quando il nome della proprietà è un numero intero:

A partire da un array associativo in cui i nomi delle proprietà sono numeri interi:

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

Invia elementi all'array:

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

Scorri l'array e fai qualcosa con il valore della proprietà.

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

L'output della console dovrebbe essere simile a questo:

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

Come puoi vedere, puoi aggirare la limitazione degli array associativi e fare in modo che il nome di una proprietà sia un numero intero.

NOTA: l'array associativo nel mio esempio è il contenuto JSON che avresti se serializzassi un oggetto Dictionary <string, string> [].

Usa un oggetto - con un numero intero come chiave - piuttosto che un array.

A volte uso un prefisso per le mie chiavi. Per esempio:

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

obj = {};

obj[key] = val;

Ora non hai alcun problema ad accedervi.