ES6 fournit une nouvelle structure de données Set. L'objet Set n'est pas un tableau et peut être utilisé pour enregistrer des objets ou des types de base. sont Les seuls , les navigateurs Chrome>38 et FF>13, ainsi que nodeJS, à avoir un bon support pour Set Certains des codes suivants peuvent être copiés sur la console. et exécutez directement ;
let set = new Set(); //或者 new Set(null); console.log(set);
ou comme ceci :
let set = new Set([1,2,3,4,4,4,4,4]); console.log( Array.from(set) ); //输出：[ 1, 2, 3, 4 ]
Comme vous pouvez le voir, ce qui précède est répété 4 est dans setUn seul y est enregistré, donc l'objet Set peut être utilisé pour dédupliquer le tableau
Set peut également être utilisé pour enregistrer NaN et undefined. S'il y a des NaN en double, Set les considérera comme A NaN (en fait NaN!=NaN);
L'objet après l'instance Set a ces propriétés et méthodes :
propriétés
Set.prototype
Set.prototype.size
Méthodes
Set.prototype.add()
Set.prototype.clear()
Set.prototype.delete()
Set.prototype.entries()
Set.prototype.forEach( )
Set.prototype.has()
Set.prototype.values()
Set.prototype[@@iterator]()
SetEn fait, nous pouvons directement utiliser des tableaux pour ce type de structure de données. Le simulé sort Bien qu'il ne puisse pas être comparé à celui d'origine, il ne peut simuler que certaines des méthodes et . attributs répertoriés ci-dessus (il y a aussi certaines fonctions qui ne peuvent pas être réalisées, comme [Symbol.species] pointe vers lui-même, mais [Symbol.species] n'existe pas dans chrome...)
<html>
<head>
<meta charset="utf-8">
</head>
<body>
<script>
"use strict";
class Set {
//对_set进行去重;
static refresh () {
let _this = this;
let __set = []
this._set.forEach(function(obj) {
if( __set.indexOf(obj) === -1 && obj!=undefined) {
__set.push(obj);
}
});
_this._set =__set;
this.size = _this._set.length;
}
constructor(arg) {
this.size = 0;
this[Symbol.species] = this;
this._set = Array.isArray(arg)&&arg||[];
Set.refresh.call(this)
}
add (obj) {
this._set.push(obj);
Set.refresh.call(this)
return this;
}
clear () {
this._set.length = 0;
return this;
}
delete (obj) {
if( this._set.indexOf(obj)!=-1 ) {
this._set[this._set.indexOf(obj)] = undefined;
};
Set.refresh.call(this);
return this;
}
/**
* @desc
* @return Entries [[],[],[],[]]
* */
entries () {
let result = [];
this.forEach(function(key, value) {
result.push([key,value]);
});
return result;
}
has () {
if( this._set.indexOf(obj)!=-1 ) return true;
}
keys () {
return this[Symbol.iterator]();
}
values () {
return this[Symbol.iterator]();
}
//直接使用数组的forEach方便啊;
forEach (fn, context) {
let _this = this;
this._set.forEach((value) => fn.call(context||value, value, value, _this) );
}
//必须支持生成器的写法;
*[Symbol.iterator] (){
let index = 0;
let val = undefined;
while(index<this.size) {
val = this._set[index];
yield val;
index++;
}
}
}
var set = new Set([0,0]);
//对Set进行基本的操作;
set.add(1).add(2).add(3).add({1:1})
set.delete(1);
set.add(1);
//使用Set的forEach方法;
set.forEach(function(key,value,s){console.log(key,value,s,"this")},{this:"this"})
//检测生成器是否正常运行;
for(let s of set) {
console.log(s)
}
//因为这个对象有Symbol.iterator， 所以使用扩展符也是好使的；
console.log([...set]);
</script>
</body>
</html>attribut size : size fait référence à la longueur de cet Set, qui a le même effet que la longueur du tableau. "
attribut constructeur : cet attribut pointe vers le constructeur Set, et ce code peut être implémenté (nouveau Set).constructor === Set //Sortie : true
ajouter une méthode, ajouter des données à l'ensemble ;
<script>
Array.from((new Set([1,2])).add(3)); // 输出：[1, 2, 3]
</script>effacer la méthode, effacer les données dans l'ensemble
let set = (new Set([1,2,3,4])); set.clear(); Array.from(set);
supprimer la méthode, supprimer le données spécifiées dans l'ensemble :
let set = (new Set([1,2,3,4])); set.delete(1); Array.from(set); //输出：[2, 3, 4]
méthode d'entrées :
let set = (new Set([1,2,3,4])); Array.from(set.entries());
méthode forEach : le forEach de l'ensemble a deux paramètres, le premier paramètre est une fonction et le deuxième paramètre est facultatif Si le deuxième paramètre est passé, alors le contexte de la fonction est le deuxième paramètre que nous passons :
<script>
let set = (new Set([1,2,3,4]));
set.forEach(function() {
console.log(arguments);
console.log(this)
},"1111");
</script>Sortie :
a. méthode, has est utilisé pour déterminer si cet ensemble a une valeur spécifiée et renvoie false ou true;
<script> let set = (new Set([1,2,3,4])); console.log(set.has(1)) //输出：true; console.log(set.has(5)) //输出：false </script>
méthode key et valeurs(), les deux méthodes renvoient un itérateur
<script>
let set = new Set([1,2,3,4]);
console.log(set.keys());
console.log(set.values());
var keys = set.keys();
for(let key of keys) {
console.log(key);
};
</script>Méthode @@iterator(), la méthode @iterator est l'itérateur par défaut de set ;
<script> let set = new Set([1,2,3,4]); let setIner = set[Symbol.iterator](); console.log(setIner.next().value) //输出：1 console.log(setIner.next().value) //输出：2 console.log(setIner.next().value) //输出：3 console.log(setIner.next().value) //输出：4 </script>
En fait, nous pouvons remplacer set[Symbol.iterator], mais cela n'affectera pas les clés et les valeurs méthodes de set ;
DÉMO complète :
var mySet = new Set();
//往mySet里面添加数据， 1 ， 5
mySet.add(1);
mySet.add(5);
mySet.add("some text");
//添加对象
var o = {a: 1, b: 2};
mySet.add(o);
mySet.has(1); // 返回：true
mySet.has(3); // 返回：false
mySet.has(5); // 返回：true
mySet.has(Math.sqrt(25)); // 返回：true
mySet.has("Some Text".toLowerCase()); // t返回：rue
mySet.has(o); // 返回：true
mySet.size; // 4
mySet.delete(5); // 从mySet里面删除5
mySet.has(5); // 输出：false, 5 已经被删除了
mySet.size; // 现在的长度为：3
// 通过 for...or循环获取数据;
// 输出: 1, "some text"
for (let item of mySet) console.log(item);
// 输出: 1, "some text"
for (let item of mySet.keys()) console.log(item);
// 输出: 1, "some text"
for (let item of mySet.values()) console.log(item);
// 输出: 1, "some text"， 对于Set来说：key和value是一样的
for (let [key, value] of mySet.entries()) console.log(key);
// 把迭代器转化为数组的第一种方式；
var myArr = [v for (v of mySet)]; // [1, "some text"]
// 把迭代器转化为数组的第二种方式；
var myArr = Array.from(mySet); // [1, "some text"]
// 也可以用next()方法，手动去获取每一个值;L'utilisation réelle de Set :
L'utilisation de set peut facilement effectuer une intersection et une union :
Pour trouver l'union, on peut donner deux solutions ou plus :
var union = (setA, setB) => {
//[...setA]这种方式目前只有babel才支持
return new Seet([...setA,...setB]);
};
var union = (setA, setB) => {
return new Set(Array.from(setA).concat(Array.from(setB)));
}Cette façon d'obtenir l'intersection, C'est presque la même chose que trouver l'intersection des tableaux ;
var intersect = (set1, set2) => {
//return [x for (x of set1) if (set2.has(x))]; 这种写法完全不行嘛....
var resultSet = new Set();
for(let set of set1) {
if(set2.has(set)) {
resultSet.add(set);
};
};
return resultSet;
};Ce qui suit le code est plus court, tellement cool. Cette méthode vient de : http://es6.ruanyifeng.com/#docs/set-map;
var intersect = (set1, set2) => {
return new Set([...set1].filter(x => set2.has(x)));
}
console.log(intersect(new Set([1,2,3,4]), new Set([2,3,4,5]))); //输出：Set {2,3,4}WeakSet est une collection de valeurs d'objet, et chaque valeur d'objet qu'il contient ne peut apparaître qu'une seule fois. WeakSet ne peut stocker que des éléments de type d'objet , tels que : Object, Array, Function, etc.; avec des références faibles WeakSet, vous n'avez pas à vous soucier des fuites de mémoire si d'autres objets le font. ne référence pas l'objet, l'objet sera automatiquement recyclé par le mécanisme de récupération de place ;
<script>
console.log(new WeakSet([{},[],()=>({1:1})]));
</script>L'objet WeakSet n'a que trois méthodes. Et l'objet WeakSet n'a pas d'attribut size ; 🎜>
Si l'objet n'a pas de référence, alors l'objet WeakSet La mémoire occupée par les objets non référencés sera recyclée. Vous pouvez exécuter la démo suivante, puis regarder la console après un moment (je verrai l'effet dans mon navigateur Chrome
weakSet
<script>
var ws = new WeakSet()
var obj = {}; ws.add(obj);
ws.add([])
setInterval(()=>{
console.log(ws);
},1000)
</script>weakSet, il sera stocké en mémoire pendant un certain temps ; > Ce qui précède est une introduction détaillée au code des nouvelles fonctionnalités d'ES6 - Structures de données de type Set et WeakSet en JavaScript Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
