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.
The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.
Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner https://github.com/mdn/interactive-examples et à envoyer une pull request !
Syntaxe
new Set([itérable]);
Paramètres
Valeur de retour
Un nouvel objet Set
.
Description
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 objetSet
, on utiliseraSet.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 objetsSet
.
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'objetSet
. 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 queSet.prototype.has(valeur)
aurait renvoyé.Set.prototype.has(valeur)
renverrafalse
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'objetSet
, dans l'ordre dans lequel les valeurs ont été insérées. On aura donc une structure semblable à un objetMap
. 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'objetSet
, dans l'ordre dans lequel elles ont été insérées. Si un paramètrethisArg
est fourni àforEach
, il sera utilisé comme valeur dethis
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 objetIterator
qui contient les valeurs correspondant à chaque élément deSet
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'objetSet
, 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'objetSet
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