Utiliser un nombre entier comme clé dans un tableau associatif en JavaScript

Question

Lorsque je crée un nouveau tableau JavaScript et que j'utilise un nombre entier comme clé, chaque élément de ce tableau jusqu'au nombre entier est créé comme étant indéfini.

Par exemple :

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

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

Comment faire pour que JavaScript utilise 2300 comme une chaîne de caractères au lieu d'un nombre entier, ou comment l'empêcher d'instancier 2299 indices vides ?

Answer 1

Utilisez un objet, comme le disent les gens. Cependant, notez que vous pouvez no ont des clés entières. JavaScript va convertir le nombre entier en chaîne de caractères . Les sorties suivantes 20, non indéfinies :

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

Answer 2

Vous pouvez simplement utiliser un objet :

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

Answer 3

Comme on le dit, JavaScript convertira une chaîne de chiffres en entier, il n'est donc pas possible de l'utiliser directement sur un tableau associatif, mais les objets fonctionneront pour vous de manière similaire, je pense.

Vous pouvez créer votre objet :

var object = {};

Et ajouter les valeurs en tant que tableau fonctionne :

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

Cela vous donnera :

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

Ensuite, vous pouvez y accéder comme à un tableau dans d'autres langues en récupérant la clé :

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

Je l'ai testé et il fonctionne.

Answer 4

Si le cas d'utilisation est le stockage de données dans une collection alors ECMAScript 6 fournit le Map type.

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)

Answer 5

Compilation d'autres réponses :

Objet

var test = {};

Lorsqu'on utilise un nombre comme clé d'une nouvelle propriété, le nombre se transforme en chaîne de caractères :

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

Lorsque l'on accède à la valeur de la propriété en utilisant le même numéro, celui-ci est à nouveau transformé en chaîne de caractères :

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

Cependant, lorsque l'on récupère les clés de l'objet, elles ne seront pas transformées en chiffres :

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

Carte

ECMAScript 6 permet d'utiliser l'objet Map ( documentation , une comparaison avec l'objet ). Si votre code est censé être interprété localement ou la table de compatibilité ECMAScript 6 semble assez 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'