Utilisation d'un entier comme clé dans un tableau associatif en JavaScript

Lorsque je crée un nouveau tableau JavaScript et que j'utilise un entier comme clé, chaque élément de ce tableau jusqu'à l'entier est créé comme non défini.

Par exemple:

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

affichera 2298 indéfinis et un 'Some string'.

Comment dois-je faire en sorte que JavaScript utilise 2300 comme chaîne au lieu d'un entier, ou comment dois-je l'empêcher d'instancier 2299 indices vides?

Utilisez un objet, comme le disent les gens. Cependant, notez que vous ne pouvez pas avoir de clés entières. JavaScript convertira l'entier en chaîne . Les sorties 20 suivantes, non indéfinies:

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

Vous pouvez simplement utiliser un objet:

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

Comme les gens le disent, JavaScript convertira une chaîne de nombre en entier, il n'est donc pas possible de l'utiliser directement sur un tableau associatif, mais les objets fonctionneront pour vous de la même manière que je pense.

Vous pouvez créer votre objet:

var object = {};

Et ajoutez les valeurs au fur et à mesure que le tableau fonctionne:

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

Cela vous donnera:

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

Après cela, vous pouvez y accéder comme un tableau dans d'autres langues pour obtenir la clé:

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

J'ai testé et fonctionne.

Si le cas d'utilisation stocke des données dans une collection, ECMAScript 6 fournit le Maptype.

C'est seulement plus lourd à initialiser.

Voici un exemple:

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

Résultat:

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

Compiler d'autres réponses:

Objet

var test = {};

Lorsque vous utilisez un nombre comme clé de nouvelle propriété, le nombre se transforme en chaîne:

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

Lors de l'accès à la valeur de la propriété en utilisant le même nombre, le nombre est à nouveau transformé en chaîne:

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

Lorsque vous récupérez les clés de l'objet, cependant, elles ne seront pas transformées en nombres:

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

Carte

ECMAScript 6 permet l'utilisation de l'objet Map ( documentation , comparaison avec Object ). Si votre code est destiné à être interprété localement ou si la table de compatibilité ECMAScript 6 semble suffisamment verte pour vos besoins, envisagez d'utiliser une carte:

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

Aucune conversion de type n'est effectuée, pour le meilleur et pour le pire:

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

Utilisez un objet au lieu d'un tableau. Les tableaux en JavaScript ne sont pas des tableaux associatifs. Ce sont des objets avec de la magie associés à toutes les propriétés dont les noms ressemblent à des entiers. Cette magie n'est pas ce que vous voulez si vous ne les utilisez pas comme une structure traditionnelle de type tableau.

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

Essayez d'utiliser un objet, pas un tableau:

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

Obtenez la valeur d'une propriété de tableau associatif lorsque le nom de la propriété est un entier:

En commençant par un tableau associatif où les noms de propriétés sont des entiers:

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

Poussez les éléments vers la baie:

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

Parcourez le tableau et faites quelque chose avec la valeur de la propriété.

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

La sortie de la console devrait ressembler à ceci:

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

Comme vous pouvez le voir, vous pouvez contourner la limitation du tableau associatif et faire en sorte qu'un nom de propriété soit un entier.

REMARQUE: Le tableau associatif dans mon exemple est le contenu JSON que vous auriez si vous sérialisiez un objet Dictionary <string, string> [].

Utilisez un objet - avec un entier comme clé - plutôt qu'un tableau.

Parfois, j'utilise un préfixe pour mes clés. Par exemple:

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

obj = {};

obj[key] = val;

Maintenant, vous n'avez aucun problème à y accéder.