Carte
Introduction
MapLa structure de données est similaire à JavaScriptcelle de 对象, mais la clé de l'objet ne peut être qu'une chaîne, et la clé de Map peut être 任意类型的值. Il convient de noter que les clés de la carte sont liées à des adresses mémoire, de sorte que certaines clés apparemment identiques ont des valeurs différentes, qui seront illustrées ci-dessous avec des exemples.
MapL'avantage de la liaison de clé et d'adresse mémoire est d'éviter la collision/le conflit d'attributs portant le même nom. Ainsi, lorsque nous développons les bibliothèques d'autres personnes, nous n'avons pas à nous soucier de détruire la valeur d'origine.
Map peut accepter un tableau comme paramètre, mais les membres du tableau doivent être des tableaux représentant des paires clé-valeur.
const map = new Map([
['name', '张三'],
['age', '18']
]);
// {'name': '张三', 'age': '18'}
Méthode d'opération
map.has('name') // 判断是否存在某个键，返回true/false
map.get('name') // 获取某个键的值，如果不存在，则返回 undefined
map.set('sex', '男') // 添加成员，如果添加重复的键，会覆盖已存在的值
map.delete('sex') // 删除某个值，成功返回 true，失败返回 false
Les clés de la carte sont liées à la mémoire, faites donc particulièrement attention à cela. Examinez de plus près les deux séries d'exemples ci-dessous :
Deux valeurs qui doivent être strictement égales pour que la Map les considère comme la même clé, sauf NaN.
const map = new Map();
map.set(['a'], 666);
map.get(['a']) // undefined
const map = new Map();
const a = ['a']
map.set(a, 666);
map.get(a) // 666
traverser
MapIl peut également être parcouru comme un tableau, mais la méthode d'opération est différente et ne peut être parcourue que par keys(), values(), et d'autres méthodes. L'interface de traversée par défaut est .entries()forEach()entries
const map = new Map([
['name', '张三'],
['age', '18']
]);
for (let item of map.keys()) {
console.log(item);
}
// 'name'
// 'age'
for (let item of map.values()) {
console.log(item);
}
// '张三'
// '18'
for (let item of map.entries()) {
console.log(item);
}
// ['name', '张三']
// ['age', '18']
for (let [key, value] of map.entries()) {
console.log(key, value);
}
// 'name' '张三'
// 'age' '18'
for (let [key, value] of map) {
console.log(key, value);
}
// 'name' '张三'
// 'age' '18'
map.forEach(function(value, key, map) {
});
WeakMap
Introduction
WeakMapSimilaire à Map, mais la clé ne peut être que 对象ou null, pas d'autres types. En même temps, les membres de WeakMap sont des références faibles, qui n'affectent pas le mécanisme de récupération de place.
Ensemble
Introduction
SetIl s'agit ES6d'une nouvelle structure de données fournie, similaire à la structure du tableau, sa clé et sa valeur sont identiques et sa valeur est unique et non répétée.
SetLui-même est un constructeur utilisé pour générer Setdes structures de données. Lors de Setl'ajout de valeurs, le type de la valeur ajoutée ne changera pas.
SetPeut accepter un tableau comme paramètre à initialiser.
const set = new Set([1, 2, 3, 4, 4, 4]);
[...set] // [1, 2, 3, 4]
ajouter des membres
Les membres peuvent add()être ajoutés à l'ensemble via la méthode, notez que les membres en double ne peuvent pas être ajoutés.
const set = new Set([1, 2, 3, 4, 4, 4]);
set.add(1) // {1, 2, 3, 4}
set.add(5) // {1, 2, 3, 4, 5}
modifier les membres
SetIl n'existe aucun moyen de modifier le membre lui-même, mais il peut être modifié d'autres manières, telles que le mappage d'un nouvel ensemble.
let set = new Set([1, 2, 3]);
set = new Set([...set].map(val => val * 2));
// {2, 4, 6}
Méthode d'opération
Setquelques autres méthodes.
const set = new Set([1, 2, 3, 4, 4, 4]);
set.add(5) // 添加成员
set.delete(1) // 删除成员
set.has(5) // 判断成员是否存在，返回 true/false
set.clear() // 清空所有成员
traverser
SetIl peut également être parcouru comme un tableau, mais la méthode d'opération est différente et ne peut être parcourue que par keys(), values(), et d'autres méthodes.entries()forEach()
const set = new Set([1, 2, 3]);
for (let item of set.keys()) {
console.log(item);
}
// 1
// 2
// 3
for (let item of set.values()) {
console.log(item);
}
// 1
// 2
// 3
for (let item of set.entries()) {
console.log(item);
}
// [1, 1]
// [2, 2]
// [3, 3]
set.forEach((value, key) => console.log(key + ' : ' + value))
// 1 : 1
// 2 : 2
// 3 : 3
intersection, union, différence
En utilisant les caractéristiques de parcours et Setles types de données qui n'ont pas de valeurs en double, vous pouvez facilement obtenir l'intersection, l'union et la différence.
const a = new Set([1, 2, 3]);
const b = new Set([3, 4, 5]);
// 交集
let intersect = new Set([...a].filter(x => b.has(x)));
// set {3}
// 并集
let union = new Set([...a, ...b]);
// Set {1, 2, 3, 4, 5}
// 差集
let difference = new Set([...a].filter(x => !b.has(x)));
// Set {1, 2, 4, 5}
Ensemble faible
Introduction
WeakSetSemblable à Set, il s'agit également d'une collection de valeurs non répétitives, mais la valeur de WeakSet ne peut être qu'un objet (un non-objet signalera une erreur) et les objets de WeakSet sont tous des références faibles.
Le mécanisme de récupération de place ne prend pas en compte les références aux objets dans le WeakSet. S'il n'y a pas d'autres références aux objets dans le WeakSet, alors la récupération de place nettoiera les objets dans le WeakSet.
const ws = new WeakSet([[1, 2], [3, 4]]);
// {[1, 2], [3, 4]}
Méthode d'opération
const ws = new WeakSet();
const obj = {
};
ws.add(obj) // 添加成员
ws.delete(obj) // 删除成员
ws.has(obj) // 判断成员是否存在，返回 true/false
Remarque : les WeakSets ne peuvent pas être traversés.
FIN