es6 set,map,symbol

ES6的Set、Map、Symbol

ES6提供了两个新的引用数据类型 set 和 map

set：

新的数据结构，可以理解为集合。类似于数组，set的值都是唯一的。但是不能使用索引来获取元素

定义：

  new Set();//创建一个空的set
  new Set(arr);//创建一个有值的set

属性和应用：

delete: 删除一个值。返回布尔值。true：删除成功 false：删除失败

let arr = [1, 2, 3, 4, 5];
let set = new Set(arr);
let res = set.delete(3);
console.log(set);//[1,2,4,5]

clear：清除所有的元素

let arr = [1, 2, 3, 4, 5];
let set = new Set(arr);
set.clear();
console.log(set);//Set(0) {size: 0}

遍历元素 forEach for...of

let arr = [1, 2, 3, 4, 5];
let set = new Set(arr); 
//----------------forEach--------------------
set.forEach((item, index) => {
    console.log(item);
    console.log(index);
})


//------------------for of--------------------------
for (const item of set) {
    console.log(item);
}
console.log(set);

旧式去重法

let arr = [4, 6, 6, 7, 9];
for (var i = 0; i < arr.length - 1; i++) {
    for (var j = i + 1; j < arr.length; j++) {
        if (arr[i] == arr[j]) {
            arr.splice(j, 1);
            j--;
        }
    }
}
console.log(arr); //[4, 6, 7, 9]

set去重

let arr = [4, 6, 6, 7, 9];
arr = [...new Set(arr)];
console.log(arr);//[4, 6, 7, 9]

map：

可以有重复的值，但是不能有重复的键

定义：

new map();

方法：

let map = new Map();
let obj = {
    name: "潜伏",
    act: "孙红雷"
}
let obj2 = {
    title: "谍战",
    info: "谍战剧是以间谍及地下秘密活动为主题"
}

set(key,value); 添加一个键值对

map.set("肖申克的救赎", "剧情");
map.set("潜伏", "恐怖");
map.set(obj, obj2);
map.set("九品芝麻官", "喜剧");
map.set("西虹市首富", "喜剧");

var v = get(key); 通过键，获取值

let v = map.get("九品芝麻官")
console.log(v);//喜剧

delete:通过键，删除一个键值对

map.delete("潜伏");
console.log(map);

clear:清空

map.clear();
console.log(map); //Map(0)
console.log(map.get(obj));//undefined

遍历
forEach
回调函数的第一个参数为 键值对中的值
回调函数的第二个参数为 键值对中的键

map.forEach((v, k) => {
    console.log("v=>" + v);
    console.log("k=>" + k);
})

for of

​ 属性: size：键值对的个数

for (const item of map) {
    //item是一个数组，有两个元素，保存了键值对中的键和值
    console.log(item[0]);
    console.log(item[1]);
}

symbol:

es6新增的基础数据类型 用于表示一个独一无二的值

Symbol()函数会返回symbol类型的值，该类型具有静态属性和静态方法。

​ 它的静态属性会暴露几个内建的成员对象；

​ 它的静态方法会暴露全局的symbol注册，且类似于内建对象类，但作为构造函数来说它并不完整，

​ 因为它不支持语法：“new Symbol()”。

let a = new Symbol();//错误写法：Symbol is not a constructor
//创建：
    Symbol(); // √
    new Symbol(); // ×

作用：

1.避免对象的属性名冲突

let a = Symbol();
let b = Symbol();
console.log(a == b);//false

2.消除魔术字符串

 ```tex
 魔术字符串：指程序中与代码耦合性非常高的字符串。
 ```

// 创建一个角色
function createRole(type) {
    if (type == race.evles) {
        console.log("创建了一个精灵");
    } else if (type == race.human) {
        console.log("创建了一个人类");
    } else if (type == race.orcish) {
        console.log("创建了一个兽人");
    }
}

var race = {
    evles: Symbol(),
    human: Symbol(),
    orcish: Symbol()
}

createRole(race.orcish);

规则：

我们创建一个symbol变量时，默认情况下打印出来始终都是symbol。 多个symbol变量之间难以区分,所以可以在创建时,添加一个字符串对其进行描述.  Symbol("描述字符")

let a = Symbol("金额");
let b = Symbol("攻击力");

// 如果两个symbol的描述字符相等， 并不代表他们两个相等。

let c = Symbol("攻击力");

console.log(a);
console.log(b);

console.log(c == b);

遍历：

symbol类型的属性是无法被 for in ，for of 等方法访问的。

​ ES6提供了一个专门访问symbol属性的方法。

​ let res = Object.getOwnPropertySymbols(对象)

​ res是一个数组，包含了该对象所有属性名中symbol值。

let age = Symbol("年龄");
let k = Symbol("技能")
let p = {
    name: "隔壁老王",
    [age]: 40,
    [k]: function() {
        console.log("修水管");
    }
}
//let res = Object.getOwnPropertySymbols(对象) 
let res = Object.getOwnPropertySymbols(p)
console.log(res);

​ ES6新增的方法，可以遍历出对象所有的常规属性名和symbol属性名。

​ Reflect.ownKeys§;

//Reflect.ownKeys(p); 
let res = Reflect.ownKeys(p);
console.log(res);