Les collections en Javascript : tableaux, objets, ensembles
Javascript propose trois types de collections :
Ces types ont une certaine parenté avec les types correspondant en Python, mais la correspondance n'est pas parfaite, attention donc aux pièges.
Array
Un Array Javascript est une suite ordonnée de valeurs, identifiées par un indice (commençant à 0).
Il se comporte en gros comme une liste Python.
// Déclaration et initialisation
let l = []; // liste vide
let l = ["a", 12, "c"];
// Longueur
l.length // -> 3
// Accès à un élément (numérotation à partir de 0)
l[2] // -> "c"
// Ajout d'un élément à la fin
l.push("d");
// Test de l'existence d'un élément
l.indexOf(12) // -> 1
l.indexOf("e") // -> -1 (non trouvé)
// Itération sur les indices : for ... in
for (let i in l)
console.log(i); // affiche 0, 1, 2, 3
// Itération sur les éléments : for ... of
for (let x of l)
console.log(x); // affiche "a", 12, "c", "d"
Note : pour rechercher si des valeurs sont dans une liste, il peut être plus efficace d'utiliser un ensemble, qui évite le parcours séquentiel de la liste (comme en Python).
Attention :
* for ... in n'itère pas sur les éléments, mais sur les indices.
Object
Un objet Javascript permet de stocker des valeurs indexées par des clés. Les clés ne sont pas ordonnées.
Notes : * Son comportement est un hybride entre les dictionnaires et les objets en Python. * Contrairement aux objets Python, on ne va jamais créer de méthodes, utiliser l'héritage, etc.
// Déclaration et initialisation
let o = {} // objet vide
let o = { fr: 'France', it: 'Italie' }; // pas besoin de guillemets autour des clés
let code='it';
let o = { fr: 'France', [code]: 'Italie' }; // Adressage indirect (peu courant)
// Accès à un élément
o.fr // -> 'France' (syntaxe recommandée)
o['fr'] // -> 'France'
o.de // -> null (pas d'erreur)
// Accès indirect
let code = 'fr';
o[code] // -> 'France'
// Ajout/modification d'un élément
o.de = 'Allemagne'
o['de'] = 'Allemagne'
o = {...o, de: 'Allemagne'} // Utilisation de "l'opérateur de décomposition" pour créer une copie de l'objet
// Liste des clés
Object.keys(o) // -> ['fr', 'it']
// Nombre de clés
Object.keys(o).length // -> 2
// Itération sur les clés : for ... in
for (let k in o)
console.log(k) // -> affiche 'fr', 'it'
Attention :
* pas de for ... of
* pas de méthode .keys()
* pas d'attribut .length
Set
Un ensemble ("Set") est une collection non ordonnée de valeurs uniques (pas de notion d'indice, pas de doublons). Il peut être utilisé pour supprimer les doublons d'une liste, ou tester efficacement l'appartenance d'une valeur à une liste.
Les manipulations ensemblistes classiques (union, intersection, ...) ne sont pas disponibles nativement 🤡, mais peuvent être implémentées assez facilement.
// Déclaration et initialisation
let s = new Set() // ensemble vide
let s = new Set(['fr', 'en', 'de']) // initialisation depuis un Array
// Ajout d'un élément
s.add('it') // élément ajouté
s.add('fr') // élément déjà présent, pas ajouté (pas de doublon)
// Test d'appartenance (attention, pas d'opérateur "in" !!)
s.has('it') // -> true
s.has('es') // -> false
// Nombre d'éléments (cardinal)
s.size // -> 4
// Itération sur les éléments : for ... of
for (let x of s)
console.log(x) // -> affiche 'fr', 'en', 'de', 'it'
Attention :
* pas de for ... in (pas d'indices)
* le nombre d'éléments s'obtient par .size, et non par .length
* la syntaxe x in s ne produit pas d'erreur, mais ne teste pas si x appartient à s