Comment utiliser les techniques Set et WeakSet_javascript dans ES6

ES6 fournit deux nouvelles structures de données : Set et WeakSet. Set est similaire à un tableau, mais les valeurs des variables membres sont uniques et il n'y a pas de valeurs en double. WeakSet est également une collection de valeurs uniques, mais elle ne peut être utilisée que pour stocker des objets.

1. Utilisation de l'ensemble

(1)Set lui-même fournit un constructeur pour générer la structure de données Set.

var s = new Set();
[2,2,2,5,8,16,2,1].map(x => s.add(x))

for(i of s){console.log(i)}
//2,5,8,16,1

(2) La fonction Set() peut accepter un tableau comme paramètre de construction pour l'initialisation.

var s = new Set([1,2,3,4,2,4,3]);
[...s]
//[1,2,3,4]

Remarque : La conversion de type ne se produit pas lors de l'ajout d'une valeur à un ensemble, donc 5 et "5" sont deux valeurs différentes. Set détermine en interne si les deux valeurs sont égales, en utilisant. = ==, ce qui signifie que les deux objets ne sont toujours pas égaux. La seule chose en dehors de la liste est NaN lui-même (l'opérateur d'égalité exacte considère que NaN n'est pas égal à lui-même)

let set = new Set();
set.add({})
set.size//1
set.add({})
set.size//2

Ensuite, le code ci-dessus signifie que puisque les deux objets vides ne sont pas exactement égaux, ce sont deux valeurs différentes.

(3)Définir les méthodes et les attributs

(3.1)Définir les attributs

Set.prototype.size : renvoie le nombre de membres de l'instance Set.
Set.prototype.constructor : la fonction Set du constructeur par défaut.

(3.2)Définir la fonction de fonctionnement

add(value) : ajoute une valeur et renvoie la structure Set elle-même.
delete(value) : supprime une certaine valeur et renvoie une valeur booléenne indiquant une suppression réussie.
has(value) : renvoie une valeur booléenne indiquant si le paramètre est membre de Set.
clear() : Efface tous les membres, aucune valeur de retour.

var set = new Set();
set.add(1).add(2).add(22).add(22);
set.size//3

set.hae(22)//true
set.has(4)//false
set.delete(2)//true

(3.3)Définir l'opération de traversée

Set dispose de quatre méthodes de parcours. Peut être utilisé pour parcourir les membres.
keys() : renvoie un traverseur de noms de clés
valeurs() : renvoie un traverseur de valeur
Entry() : renvoie un traverseur de paires clé-valeur
forEach() : utilisez la fonction de rappel pour parcourir chaque membre

Remarque : Puisque Set n'a pas de nom de clé, seulement un nom de valeur, les résultats renvoyés par key() et values() sont les mêmes,

let set = new Set(['red','green','blue']);
for(let item of set.keys()){
console.log(item);
}
//red,green,blue
for(let item of set.values()){
console.log(item);
}
//red,green,blue
for(let item of set.entries()){
console.log(item);
}
//["red","red"]
//["green","green"]
//["blue","blue"]

//所以，entries方法返回的遍历器同时包括键名和值，所以每次输出的是一个数组。其实成员都是完全一样的。

Remarque : Set est traversable par défaut, et sa fonction de génération de traverseur par défaut est sa méthode de valeurs.
Cela signifie que vous pouvez omettre la méthode des valeurs et utiliser directement for...of pour parcourir.

var set = new Set([1,2,3,4]);
for(let x of set){
console.log(x);
}
//1
//2
//3
//4

Si vous utilisez l'opérateur spread (...), une boucle for...of est utilisée en interne, elle peut donc également être utilisée pour la structure Set.

let set = new Set(['red','green','blue']);
let arr = [...set];
//['red','green','blue'];

(3.4)Set implémente l'ensemble d'union, d'intersection et de différence

let set1 = new Set([1,2,3,4,5,6]);
let set2 = new Set([4,5,6,7,8,9]);

//并集
let union = new Set([...set1,...set2]);
//[1,2,3,4,5,6,7,8,9]
//交集
let intersect = new Set([...set1].filter(x => b.has(s)));
//[4,5,6]
//差集
let intersect = new Set([...set1].filter(x => !b.has(s)));
//[1,2,3,4]

(3.5)Set implémente l'utilisation de forEach

let set = new Set([1,2,3,4,5,6]);
set.forEach(value,key)=>consloe.log(vlaue+1);
//2
//3
//4
//5
//6
//7

Remarque : Le paramètre de la méthode forEach est une fonction de traitement, qui à son tour est la collection (valeur de clé, nom de clé) elle-même. De plus, la méthode forEach possède un deuxième paramètre qui représente l'objet auquel elle est liée.

2. Utilisation de WeakSet

WeakSet est similaire à Set et est également une collection de valeurs non répétitives. Mais il ne peut être utilisé que pour stocker des objets. Il ne peut pas s'agir d'un autre type de valeur.
WeakSet est un constructeur. Peut accepter des tableaux et des objets de type tableau comme arguments. (En fait, n'importe quel objet avec une interface itérable peut être utilisé comme paramètre de WeakSet). Tous les membres du tableau deviendront automatiquement membres de l'objet instance WeakSet.
var a = nouveau [[1,2],[3,4]];
var ws = nouveau WeakSet(a);

var ws = new WeakSet();
ws.add(1);//TypeError:Invalid value used in weak set 
ws.add(Symbol);//TypeError:Invalid value used in weak set 

Ajoutez une valeur et un symbole, et une erreur sera signalée en même temps.

La structure WeakSet a les méthodes suivantes
WeakSet.protoptype.add(value) : ajoute un nouveau membre à l'instance WeakSet.
WeakSet.protoptype.delete(value) : supprime le membre spécifié de l'instance WeakSet.
WeakSet.protoptype.has(value) : renvoie une valeur booléenne indiquant si une valeur se trouve dans une instance WeakSet.

var ws = new WeakSet();
var obj = {};
var foo = {};
ws.add(window);
ws.add(obj);
ws.has(window);//true
ws.has(foo);false
ws.delete(window);//true
ws.has(window);//false

WeakSet ne peut pas être traversé car les membres sont des références faibles et peuvent disparaître à tout moment. Traversal ne peut garantir l'existence des membres. Il se peut que juste une fois le parcours terminé, les membres ne soient plus disponibles. Une utilisation de WeakSet consiste à stocker les nœuds DOM sans se soucier des fuites de mémoire lorsque ces nœuds sont supprimés du document.