在ES6之前 引用类型的数据 有 Array 和 Object，现在新增了 Set和Map两种类型的引用类型数据

1
2
3
4
Array  ：  [1, 2, 3, 4, 5, 6]
Object ：  {a: 1, b: 2, c: 3}
Set    ：  {'pa', 'ac', 'da', 09, 5, 6}
Map    ：  {a=>'a', b=>'b', c=>'c'}

set 数据类型

set 数据类型 {1,2,3,4,5} 是一个集合 区别于对象 和数组

数据类型声明

1
2
3
4
5
6
7
8
9
{
    // 声明一个set数据类型
    let list = new Set();
    // 添加元素。
    list.add(1);
    list.add(2);
    // 获取 set数据类型的长度 size 属性
    console.log(list.size); // 2
}

将数组转换成 set 数据类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
    // 将数组转换成 set 数据类型
    let array = [1, 2, 3, 4, 5];
    let list = new Set(array);
    console.log(list); // {1, 2, 3, 4, 5}
    // set 数据类型中的数据都是唯一的
    // 不同的数据类型 将会被保留
    let array1 = [1, 2, 3, 4, 5, '2'];
    let list1 = new Set(list1);
    console.log(list1); // {1, 2, 3, 4, 5, '2'}
}

set 数据类型的 操作

1
2
3
4
5
6
7
8
9
10
11
{
    let arr = [1, 2, 3, 4];
    let list = new Set(arr);
    console.log(list.add(5));    // {1, 2, 3, 4, 5}
    console.log(list.delete(0)); 
    // true　删除成功后返回 true 失败返回 false
    console.log(list.has(1));    // true　判断是否存在
    console.log(list.clear());   
    // undefinded 清空之后 list.clear 返回undefinded
    console.log(list);           // {}
}

遍历 set 数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
    let arr = ['a', 'b', 'c', 'd', 'e'];
    let list = new Set(arr);
    // set 数据类型的值 无论是key 还是 value 都是同一个值
    for (let key of list.keys()) {
        console.log(key); // a,b,c,d,e
    }
    for (let value of list.values()) {
        console.log(value); // a,b,c,d,e
    }
    for (let [key, value] of list.entries()) {
        console.log(key, value); // a a, b b, c c, d d, e e
    }
    list.forEach((item) => {
        console.log(item); // a,b,c,d,e
    })
}

set map array object 数据的增，删，改，查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
{
    // 写法对比
    let set = new Set();
    let map = new Map();
    let arr = [];
    let obj = {};
    // 增
    let item = { t: 1 };
    set.add(item);
    map.set('t', 1);
    arr.push({ t: 1 });
    obj.t = 1;
    console.log(set, map, arr, obj); // {{t:1}} {'t'=> 1} [{t:1}] {t:1}
    // 查
    let setHas = set.has(item);
    let mapHas = map.has('t');
    let arrHas = arr.find((item) => {
        return item
    });
    let objHas = 't' in obj;
    console.log(setHas, mapHas, arrHas, objHas); // true true {t: 1} true
    // 改
    set.forEach((item) => {
        return item.t ? item.t = 2 : '';
    });
    map.set('t', 2);
    arr.forEach((item) => {
        return item.t ? item.t = 2 : '';
    });
    obj.t = 2;
    console.log(set, map, arr, obj); // {{t: 2}} {'t'=> 2} [{t:2}] {t:2}
    // 删
    set.forEach((item) => {
        return item.t ? set.delete(item) : '';
    });
    map.delete('t');
    let index = arr.findIndex(item => item.t);
    arr.splice(index, 1);
    delete obj.t;
    console.log(set, map, arr, obj); // {} {} [] {}
}

WeakSet 数据类型

1
2
3
4
5
6
7
8
9
{
    // 只能添加对象数据类型。
    let weakList = new WeakSet();
    let arg = {};
    weakList.add(arg);
    console.log(weakList); // {Object {}}
    // WeakSet 没有 clear 方法  没有size 属性 不可遍历
}

map 数据类型

map 的key 可以是任何的数据类型 ,value 也可以是任何数据类型的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
{
    // map 的key 可以是任何的数据类型 ,value 也可以是任何数据类型的值
    let map = new Map();
    let arr = ['1'];
    // 设置里面的值 set
    map.set(arr, 456);
    console.log(map);
    // 获取里面的值 get
    let value = map.get(arr); //  {["1"] => 456}
    console.log(value);  // 456
    // 第二种声明方式
    let m = new Map([['a', 1], ['b', 2]]);
    console.log(m); // {"a" => 1, "b" => 2}
    // 跟set 数据一样都具有 delete clear has 这几个属性
    // 遍历方法也相同。
}

WeakMap 数据类型 和WeakSet 数据类型的操作方法相同。