6.22 es6 set map

对象扩展

键值可以是变量，也可以，对字符串进行拼接的操作

var obj = {};
obj['get'+'name'] = 'xyz';
var x = 'name';
var obj = {
   [x]:'abc',
   [x+'set']:'hello'
}

链判断运算符 ?.

message.body.user.firstName //这样多层访问容易出错
message&&
message.boby&&
message.body.user&&
message.body.user.firstName//太麻烦
message?.body?.user?.firstName//链判断

message?.body <===> message === null ? undefined:message.body

Set

Set数据结构类似数组，成员唯一（数值类型完全相等才算相等），没有重复的值

定义

var set = new Set();
set.add(1).add(2) // Set(2) {1,2}
//第二种方式
var set2 = new Set([1,2,1,2,3,3,4]);

属性和方法

1. 添加
   set.add(value)
2. 删除
   set.delete(value) 返回bool值
3. 清除所有值
   set.clear()
4. 判断是否包含某值
   set.has(value)
5. 长度
   set.size

与数组间的结构转换

1. Array.from(set)

const set = new Set([1,2,3,4,5]);
let arr = Array.from(set);

2. 扩展运算符

let arr = [...new Set([1,2,3,4,5])]

应用

数组去重

1. 利用Set数据结构

var arr = [...new Set([1,1,1,23,4,3,23,3])]

2. 利用双重for循环

var arr = [1, 1, 1, 23, 4, 3, 23, 3];
for (var i = 0; i < arr.length; i++) {
    for (var j = i + 1; j < arr.length; j++) {
        if (arr[i] == arr[j]) {
            arr.splice(j, 1);
            j--;
        }
    }
}
console.log(arr);

3.利用indexOf

var arr = [1, 1, 1, 23, 4, 3, 23, 3];
var arr1 = [];
for (var i = 0; i < arr.length; i++) {
    if (arr1.indexOf(arr[i]) == -1) {
        arr1.push(arr[i])
    }
}
console.log(arr1);

求交集并集补集

var a1 = [2, 3, 4, 2, 2, 5, 3, 4];
var a2 = [7, 8, 3, 2, 3, 5];

1. 并集

var arr = [...new Set(a1.concat(a2))];

2. 交集

var arr = [...new Set(a1)].filter(v => new Set(a2).has(v))

3. 差集

var arr = [...new Set(a1)].filter(v => !new Set(a2).has(v))

Map

Map数据结构，类似于对象，但键可以是任何数据类型包括对象

定义

const m = new Map();
m.set(key,value).set({id:1},18); //Map(2) {key => value, {id:1} => 18}
//另外一种定义方式
const m = new Map([[key,value],[{id:1},18]])

属性和方法

1. 长度
   m.size
2. 添加值
   m.set(key,value)
3. 读取值
   m.get(key)
   注意：键值必须要数据类型和值都相等
   没找到返回undefined
4. 判断否个键是否存在
   m.has(key) 返回bool值
5. 删除某个键 返回bool值
   m.delete(key)
6. 清除所有成员
   m.clear()

Map遍历方法

for…of

const m = new Map([['a',1],['b',2],['c',3]]);

for (let k of m.keys()) {
  console.log(k)  // a,b,c
}

for (let v of m.values()) {
   console.log(v) // 1,2,3
}
for (let [k,v] of m) {
   console.log(k,v) //a,1,b,2,c,3
}

类型转换

const m = new Map([[‘a’,1],[‘b’,2],[‘c’,3]]);

1. map转化成数组

[...m.keys()] //键数组  ['a','b','c']
[...m.values()] //值数组[1,2,3]
[...m]  //包括键和值的数组 [['a',1],['b',2],['c',3]]

2. map类型转换成object

var o = {};
for (let [k,v] of m) {
  o[k] = v;
}

3. object 转换成map

let obj = {'name': 'zs','age': 12};
const m =  new Map(Object.entries(obj));

//另外一种方式
const m2 = new Map();
for (let k in obj) {
   m2.set(k,obj[k])
}

for … of 循环

适用任何数据结构，除了对象（没有iterator迭代器）

1. 数组循环

var arr = [1,2,3];
for(let v of arr) {
   console.log(v); //1 2 3 
}

2. Set中运用

```javascript
var set = new Set([1,2,3]);
for (var v of set) {
   console.log(v); //1 2 3 
}

3.Map中的运用

const m = new Map([['a',1],['b',2],['c',3]]);

for (let k of m.keys()) {
  console.log(k)  // a,b,c
}

for (let v of m.values()) {
   console.log(v) // 1,2,3
}
for (let [k,v] of m) {
   console.log(k,v) //a,1,b,2,c,3
}

4. 对象

var obj = {id:1,name:'zs'};
for (let v of obj) {
   console.log(v); //报错
}
//解决方法
for (let [k,v] of Object.entries(obj)) {
   console.log(k,v);
}

forEach的弊端

这种写法的问题在于，无法中途跳出forEach循环**，break命令或return命令都不能奏效**。