Set 和 Map 数据结构

一、ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。也可以结合map（循环遍历数组），filter（过滤数组）使用

例1：
const set = new Set([1, 2, 3, 4, 4]);
console.log( [...set] )   // [1,2,3,4]

例2：
const items = new Set([1, 2, 3, 4, 5, 5, 5, 5]);
console.log( items )    // [1,2,3,4,5]
console.log( items.size )    // 5

1.1、去除数组的重复成员 [...new Set(array)]

let arr = [1,2,3,4,4,5,5,7,1,2,3,8]
let a1 = [...new Set(arr)]
console.log( a1 );    //[1,2,3,4,5,7,8]

1.2、Set两个对象总是不相等的，由于两个空对象不相等，所以它们被视为两个值。

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

二、操作方法（用于操作数据）

--add(value)：添加某个值，返回 Set 结构本身。
--delete(value)：删除某个值，返回一个布尔值，表示删除是否成功。
--has(value)：返回一个布尔值，表示该值是否为Set的成员。
--clear()：清除所有成员，没有返回值。

2.1、Array.from方法可以将 Set 结构转为数组。

const items = new Set([1, 2, 3, 4, 5]);
const array = Array.from(items);
console.log( items );    // Set { 1, 2, 3, 4, 5 }
console.log( array );    // [ 1, 2, 3, 4, 5 ]


去除数组重复数据
function dedupe(array) {
    return Array.from(new Set(array));
};
dedupe([1, 1, 2, 3]) // [1, 2, 3]

三、遍历方法（用于遍历成员）

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

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

--values()：
    for (let item of set.values()) {
      console.log(item);    // red  green  blue
    };

--entries()：
    for (let item of set.entries()) {
      console.log(item);
    };
    // ["red", "red"]
    // ["green", "green"]
    // ["blue", "blue"]

--forEach();
    set = new Set([1, 4, 9]);
    set.forEach(
        (value, key) => {
            console.log(key + ' : ' + value)
        }
     )
    // 1 : 1
    // 4 : 4
    // 9 : 9

四、map和filter方法用于 Set

--map 用于循环遍历数组
    let set = new Set([1, 2, 3]);
    set = new Set([...set].map(x => x * 2));
    // 返回Set结构：{2, 4, 6}

--filter 用于过滤
    let set = new Set([1, 2, 3, 4, 5]);
    set = new Set([...set].filter(x => (x % 2) == 0));
    // 返回Set结构：{2, 4}

4.1、Set 的并集（Union）、交集（Intersect）和差集（Difference）。

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}

// 差集
let difference = new Set([...a].filter(x => !b.has(x)));
// Set {1}

五、Map

5.1、类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object 结构提供了“字符串—值”的对应，Map 结构提供了“值—值”的对应，是一种更完善的 Hash 结构实现。如果你需要“键值对”的数据结构，Map 比 Object 更合适。

const m = new Map();
const o = {p: 'Hello World'};

m.set(o, 'content')
m.get(o) // "content"

m.has(o) // true
m.delete(o) // true
m.has(o) // false

5.2、如果对同一个键多次赋值，后面的值将覆盖前面的值

const map = new Map();
map
  .set(1, 'aaa')
  .set(1, 'bbb');

map.get(1) // "bbb"

5.3、注意，只有对同一个对象的引用，Map 结构才将其视为同一个键。这一点要非常小心。

const map = new Map();
map.set(['a'], 555);
map.get(['a']) // undefined

上面代码的set和get方法，表面是针对同一个键，但实际上这是两个值，内存地址是不一样的，因此get方法无法读取该键，返回undefined。


const map = new Map();
const k1 = ['a'];
const k2 = ['a'];
map
  .set(k1, 111)
  .set(k2, 222);
map.get(k1) // 111
map.get(k2) // 222

变量k1和k2的值是一样的，但是它们在 Map 结构中被视为两个键。

5.4、实例的属性和操作方法

--size();属性返回 Map 结构的成员总数
    const map = new Map();
    map.set('foo', true);
    map.set('bar', false);
    map.size // 2

--set(key, value);设置键名key对应的键值为value，然后返回整个 Map 结构。
    let map = new Map()
        .set(1, 'a')
        .set(2, 'b')
        .set(3, 'c');
        // set方法返回的是当前的Map对象，因此可以采用链式写法。

--get(key)读取key对应的键值，如果找不到key，返回undefined。
    const m = new Map();
    const hello = function() {console.log('hello');};
    m.set(hello, 'Hello ES6!') // 键是函数
    m.get(hello)  // Hello ES6!

--has(key);返回一个布尔值，表示某个键是否在当前 Map 对象之中。
    const m = new Map();
    m.set('edition', 6);
    m.set(262, 'standard');
    m.set(undefined, 'nah');
    m.has('edition')     // true
    m.has('years')       // false
    m.has(262)           // true
    m.has(undefined)     // true

--delete(key);删除某个键，返回true。如果删除失败，返回false。
    const m = new Map();
    m.set(undefined, 'nah');
    m.has(undefined)     // true
    m.delete(undefined)
    m.has(undefined)       // false

--clear();清除所有成员，没有返回值。
    let map = new Map();
    map.set('foo', true);
    map.set('bar', false);
    map.size // 2
    map.clear()
    map.size // 0

5.5、遍历方法

--keys()：返回键名的遍历器。
--values()：返回键值的遍历器。
--entries()：返回所有成员的遍历器。
--forEach()：遍历 Map 的所有成员。

5.6、Map 结构转为数组结构，比较快速的方法是使用扩展运算符（...）。

const map = new Map([
    [1, 'one'],
    [2, 'two'],
    [3, 'three']
]);

[...map.keys()]    // [1, 2, 3]
[...map.values()]    // ['one', 'two', 'three']
[...map.entries()]    // [[1,'one'], [2, 'two'], [3, 'three']]
[...map]    // [[1,'one'], [2, 'two'], [3, 'three']]