3. set、map

Set是一种叫做集合的数据结构，Map是一种叫做字典的数据结构

区别：

• 共同点：集合、字典都可以存储不重复的值
• 不同点：集合是以[值，值]的形式存储元素，字典是以[键，值]的形式存储

set是es6新增的一种数据结构，是类数组。最大的特性是所有元素是唯一的。本身是一个构造函数，使用new set()。

Set

• Set是es6新增的数据结构，类似于数组，但是成员的值都是唯一的，没有重复的值，我们一般称为集合
• Set本身是一个构造函数，用来生成 Set 数据结构

 const s = new Set();

add

• 添加某个值，返回 Set 结构本身
• 当添加实例中已经存在的元素，set不会进行处理添加

 s.add(1).add(2).add(2); // 2只被添加了一次

delete

• 删除某个值，返回一个布尔值，表示删除是否成功

 s.delete(1)

has

• 返回一个布尔值，判断该值是否为Set的成员

s.has(2)

clear

s.clear()

遍历

• keys()：返回键名的遍历器
• values()：返回键值的遍历器
• entries()：返回键值对的遍历器
• forEach()：使用回调函数遍历每个成员

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"]

去重

扩展运算符和Set 结构相结合实现数组或字符串去重

// 数组
let arr = [3, 5, 2, 2, 5, 5];
let unique = [...new Set(arr)]; // [3, 5, 2]

// 字符串
let str = "352255";
let unique = [...new Set(str)].join(""); // ""

实现并集、交集、和差集

let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);
 
// 并集
let union = new Set([...a, ...b]);
// Set {1, 2, 3, 4}
 
// 交集
let intersect = new Set([...a].filter(x => b.has(x)));
 // set {2, 3}
 
 // （a 相对于 b 的）差集
 let difference = new Set([...a].filter(x => !b.has(x)));
 // Set {1}

Map

• Map 是一个带键的数据项的集合，就像一个 Object 一样。 但是它们最大的差别是 Map 允许任何类型的键（key）。
• Map本身是一个构造函数，用来生成 Map 数据结构

 const m = new Map()

size

size属性返回 Map 结构的成员总数

const map = new Map();
map.set('foo', true);
map.set('bar', false);

map.size // 2

set

• 设置键名key对应的键值为value，然后返回整个 Map 结构
• 如果key已经有值，则键值会被更新，否则就新生成该键
• 同时返回的是当前Map对象，可采用链式写法

 const m = new Map();
 
 m.set('edition', 6)        // 键是字符串
 m.set(262, 'standard')     // 键是数值
 m.set(undefined, 'nah')    // 键是 undefined
 m.set(1, 'a').set(2, 'b').set(3, 'c') // 链式操作

get

get方法读取key对应的键值，如果找不到key，返回undefined

const m = new Map();

const hello = function() {console.log('hello');};
m.set(hello, 'Hello!') // 键是函数

m.get(hello)  // Hello!

has

has方法返回一个布尔值，表示某个键是否在当前 Map 对象之中

const m = new Map();

m.set('a', 6);
m.set(666, 'xxx');
m.set(undefined, 'nono');

m.has('a')     // true
m.has('b')       // false
m.has(666)           // true
m.has(undefined)     // true

delete

delete方法删除某个键，返回true。如果删除失败，返回false

const m = new Map();
m.set(undefined, 'nah');
m.has(undefined)     // true

m.delete(undefined)
m.has(undefined)       // false

clear

clear方法清除所有成员，没有返回值

let map = new Map();
map.set('foo', true);
map.set('bar', false);

map.size // 2
map.clear()
map.size // 0

遍历

Map结构原生提供三个遍历器生成函数和一个遍历方法：

• keys()：返回键名的遍历器
• values()：返回键值的遍历器
• entries()：返回所有成员的遍历器
• forEach()：遍历 Map 的所有成员 遍历顺序就是插入顺序

const map = new Map([
  ['F', 'no'],
  ['T',  'yes'],
]);

for (let key of map.keys()) {
  console.log(key);
}
// "F"
 // "T"
 
 for (let value of map.values()) {
   console.log(value);
 }
 // "no"
 // "yes"
 
 for (let item of map.entries()) {
   console.log(item[0], item[1]);
 }
 // "F" "no"
 // "T" "yes"
 
 // 或者
 for (let [key, value] of map.entries()) {
   console.log(key, value);
 }
 // "F" "no"
 // "T" "yes"
 
 // 等同于使用map.entries()
 for (let [key, value] of map) {
   console.log(key, value);
 }
 // "F" "no"
 // "T" "yes"
 
 map.forEach(function(value, key, map) {
   console.log("Key: %s, Value: %s", key, value);
 });