Set

L'objet Set (Ensemble en français) permet de stocker des valeurs uniques, de n'importe quel type, que ce soit des valeurs d'un type primitif ou des objets.

Syntaxe

 new Set([itérable]);

Paramètres

itérable: Paramètre optionnel. Si un objet itérable est donné comme argument, l'ensemble de ses éléments sera ajouté au nouvel objet Set. Si null est fourni comme argument ou qu'aucun argument n'est fourni, il sera traité comme undefined.

Les objets Set sont des ensembles de valeurs. Il est possible d'itérer sur les éléments contenus dans l'objet Set dans leur ordre d'insertion. Une valeur donnée ne peut apparaître qu'une seule fois par Set.

Égalité des valeurs

Chaque valeur d'un Set doit être unique, il faut donc tester l'égalité des valeurs contenues. Cette égalité n'est pas la même que celle de l'opérateur ===. Notamment, pour les objets Set, +0 (qui, selon l'égalité stricte, est égal à -0) et -0 sont des valeurs différentes. Cela a toutefois été changé avec la dernière version d'ECMAScript 2015 (ES6). Voir le tableau de compatibilité ci-après quant à la prise en charge de l'égalité des clés pour 0 et -0.

NaN and undefined peuvent être enregistrés dans un objet Set. NaN est considéré comme NaN (bien que NaN !== NaN).

Propriétés

Set.length: La valeur de la propriété length est 0.

Note : Pour compter le nombre d'éléments d'un objet Set, on utilisera Set.prototype.size.
get Set[@@species]: Le constructeur utilisé pour créer des objets dérivés.
Set.prototype (en-US): Représente le prototype du constructeur Set. Cela permet d'ajouter des propriétés à tous les objets Set.

Instances de `Set`

Toutes les instances de Set héritent de Set.prototype (en-US).

Propriétés

Set.prototype.constructor: Renvoie la fonction qui crée le prototype d'une instance. Par défaut, ce sera la fonction Set.
Set.prototype.size: Renvoie le nombre de valeurs contenues dans l'objet Set.

Méthodes

Set.prototype.add(valeur): Ajoute un nouvel élément à l'objet Set avec la valeur donnée. La valeur de retour est l'objet Set.
Set.prototype.clear(): Retire tous les éléments de l'objet Set.
Set.prototype.delete(valeur): Retire l'élément associé à la valeur et renvoie la valeur que Set.prototype.has(valeur) aurait renvoyé. Set.prototype.has(valeur) renverra false après la suppression.
Set.prototype.entries(): Renvoie un nouvel objet Iterator qui contient un tableau de [valeur, valeur] pour chaque élément de l'objet Set, dans l'ordre dans lequel les valeurs ont été insérées. On aura donc une structure semblable à un objet Map. Ici, chaque entrée aura la même valeur pour la clé et la valeur.
Set.prototype.forEach(fnCallback[, thisArg]): Appelle la fonction fnCallback pour chaque valeur présente dans l'objet Set, dans l'ordre dans lequel elles ont été insérées. Si un paramètre thisArg est fourni à forEach, il sera utilisé comme valeur de this pour chaque appel de la fonction de callback.
Set.prototype.has(valeur): Renvoie un booléen qui indique si un des éléments de l'ensemble possède cette valeur.
Set.prototype.keys(): Cette fonction correspond à la fonction values() et renvoie un nouvel objet Iterator qui contient les valeurs correspondant à chaque élément de Set dans l'ordre dans lequel ils ont été insérés.
Set.prototype.values(): Renvoie un nouvel objet Iterator qui contient les valeurs pour chacun des éléments de l'objet Set, dans l'ordre dans lequel ils ont été insérés.
Set.prototype[@@iterator](): Renvoie un nouvel objet Iterator qui contient les valeurs pour chaque élément de l'objet Set dans leur ordre d'insertion.

Exemples

Utiliser l'objet `Set`

var monSet = new Set();

monSet.add(1);         // { 1 }
monSet.add(5);         // { 1, 5 }
monSet.add("du texte");// { 1, 5, "du texte" }

monSet.has(1); // true
monSet.has(3); // false, 3 n'a pas été ajouté à l'ensemble
monSet.has(5);              // true
monSet.has(Math.sqrt(25));  // true
monSet.has("Du Texte".toLowerCase()); // true

monSet.size; // 3

monSet.delete(5); // retire 5 du set
monSet.has(5);    // false, 5 a été retiré de l'ensemble

monSet.size; // 2, on a retiré une valeur de l'ensemble
console.log(monSet); // Set [ 1, "du texte" ]

Itérer sur des ensembles (`Set`)

// On itère sur les différents éléments de l'ensemble
// ici on affiche : 1, "du texte"
for (let item of monSet) console.log(item);

// ici on affiche les clés de l'ensemble : 1, "du texte"
for (let item of monSet.keys()) console.log(item);

// ici on affiche les valeurs de l'ensemble : 1, "du texte"
for (let item of monSet.values()) console.log(item);

// ici on affiche les clés de l'ensemble : 1, "du texte"
//(ici, les clés et les valeurs sont les mêmes)
for (let [clé, valeur] of monSet.entries()) console.log(clé);

// Une méthode de conversion avec Array.from
var monTableau = Array.from(monSet);    // [1, "du texte"]

// Cela fonctionnera également dans un document HTML
monSet.add(document.body);
monSet.has(document.querySelector("body")); // true

// convertir un tableau (Array) en ensemble (Set) et vice versa
monSet2 = new Set([1,2,3,4]);
monSet2.size; // 4
[...monSet2]; // [1,2,3,4]

// L'intersection peut être calculée avec
var intersection = new Set([...set1].filter(x => set2.has(x)));

// La différence pourra être simulée avec
var différence = new Set([...set1].filter(x => !set2.has(x)));

// On peut itérer sur les entrées d'un ensemble avec forEach
mySet.forEach(function(value) {
  console.log(value);
});

// 1
// 2
// 3
// 4

Implémenter des opérations ensemblistes

function isSuperset(set, subset) {
  for (var elem of subset) {
    if (!set.has(elem)) {
      return false;
    }
  }
  return true;
}

function union(setA, setB) {
  var union = new Set(setA);
  for (var elem of setB) {
    union.add(elem);
  }
  return union;
}

function intersection(setA, setB) {
  var intersection = new Set();
  for (var elem of setB) {
    if (setA.has(elem)) {
      intersection.add(elem);
    }
  }
  return intersection;
}

function difference (setA, setB) {
  var difference = new Set(setA);
  for (var elem of setB) {
    difference.delete(elem);
  }
  return difference;
}

// Exemples
var setA = new Set([1,2,3,4]),
    setB = new Set([2,3]),
    setC = new Set([3,4,5,6]);

isSuperset(setA, setB);   // => true
union(setA, setC);        // => Set [1, 2, 3, 4, 5, 6]
intersection(setA, setC); // => Set [3, 4]
difference(setA, setC);   // => Set [1, 2]

Les relations avec les objets `Array`

var monTableau = ["valeur1", "valeur2", "valeur3"];

// On peut utiliser le constructeur Set pour transformer un Array en Set
var monSet = new Set(monTableau);

monSet.has("valeur1"); // renvoie true

// Et utiliser l'opérateur de décomposition pour transformer un Set en Array.
console.log([...monSet]); // affichera la même chose que monTableau

Les relations avec les objets `String`

var maChaine = "CouCou";

var monEnsemble = new Set(maChaine);
// Set {"C","o","u" }
monEnsemble.size; // 3

Dédoublonner un tableau

const nombres = [2,3,4,4,2,2,2,4,4,5,5,6,6,7,5,32,3,4,5];
console.log([...new Set(nombres)]);
// affichera [2, 3, 4, 5, 6, 7, 32]

Spécifications

Spécification	État	Commentaires
ECMAScript 2015 (6th Edition, ECMA-262) La définition de 'Set' dans cette spécification.	Standard	Définition initiale.
ECMAScript (ECMA-262) La définition de 'Set' dans cette spécification.	Standard évolutif

Compatibilité des navigateurs

BCD tables only load in the browser

Set

Syntaxe

Paramètres

Valeur de retour

Description

Égalité des valeurs

Propriétés

Instances de `Set`

Propriétés

Méthodes

Exemples

Utiliser l'objet `Set`

Itérer sur des ensembles (`Set`)

Implémenter des opérations ensemblistes

Les relations avec les objets `Array`

Les relations avec les objets `String`

Dédoublonner un tableau

Spécifications

Compatibilité des navigateurs

Voir aussi