# Set  
## 说明  
类似于数组，但是其值都是唯一的，不能重复  
## 语法  
Set本身是一个构造函数，用来生成Set数据结构  



```
var set = new Set(array)
```
Set函数可以接受一个数组（或者具有 iterable 接口的其他数据结构）作为参数，用来初始化  

## 方法  
### size  
Set实例的成员总数  
```
set.size
```


### add  
添加某个值，返回set结构本身  
```
set.add(value)
```

### delete  
删除某个值，返回一个布尔值，表示删除是否成功  
```
set.delete(value)
```

### has  
返回一个布尔值，用于检测某个值是否为set实例中的成员  
```
set.has(value)
```

### clear  
清除所有成员，没有返回值  
```
set.clear()
```


## 遍历Set结构  
### set.keys()
遍历键名  Set.prototype.keys()
```
let a = [1,2,3,4,4,2,3,1]
    let set1 = new Set(a)
    for (let key of set1.keys()) {
        console.log(key)
    }
```

### set.values()
遍历值 Set.prototype.values()  
```
let a = [1,2,3,4,4,2,3,1]
    let set1 = new Set(a)
    for (let key of set1.values()) {
        console.log(key)
    }
```

### set.entries()
遍历整体键值对 
```
let a = [1,2,3,4,4,2,3,1]
    let set1 = new Set(a)
    for (let key of set1.entries()) {
        console.log(key)
    }
```



# Map数据结构  
## 说明  
类似与对象，但是map为值-值对的集合，但是map的键可以是任意类型的数据  
## 语法  
使用Map构造函数创建,此时需要接受一个数组作为参数且数组内成员是一个个表示键值对的数组  
```
var array = [[name,value],[name,value]]
var map = new Map(array)
```

eg  

```
let a = [[1,"hello"],[2,"world"]]
let map = new Map(a)
console.log(map)
```
![map-result](https://cdn.jsdelivr.net/gh/RK-LS/blogphoto@master/common-resource/map-result.4ohat3py1ki0.jpg)  

## map的属性和方法  
### size属性  
返回Map结构的成员总数  
```
map.size
```

### set()方法  
设置键名key对应的键值为value，然后返回整个 Map对象。若key已经有值，则键值会被更新，否则就新生成该键。

可以链式调用(返回map对象)
```
map.set(key,value)
```


### get()方法  
用于获取map中的某个key对应的键值，若未找到则返回undefined  
```
map.get(key)
```

### has()方法  
返回一个布尔值，表示某个键是否在当前 Map 对象之中  
```
map.has(key)
```

### delete()方法  
删除某个键，返回true。如果删除失败，返回false  
```
map.delete(key)
```

### clear()方法  
清除所有成员，没有返回值  
```
map.clear()
```

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

ES6-set和map数据结构

# 说明  
ES6新增的原始数据类型Symbol,表示独一无二的值。  
Symbol类型的值就是Symbol()  




# 语法  
通过Symbol函数生成  
```
let a = Symbol();
console.log(a)//输出结果为Symbol()
console.log(typeof(a))//输出结果为symbol
```

# 注意
- Symbol函数前不能使用new命令，否则会报错。这是因为生成的 Symbol 是一个原始类型的值，不是对象  
- 如果 Symbol的参数是一个对象，就会调用该对象的toString方法，将其转为字符串，然后才生成一个 Symbol值  
- Symbol 值不能与其他类型的值进行运算，会报错  

# 参数  
用于描述，便于开发人员区分  
## eg    
```
let a = Symbol("one");
let arr1 = {[a]:"1"}
console.log(arr1)//{Symbol(one): "1"}
```

ES6-Symbol数据类型

# 拓展运算符  
## ...运算符 
用来拆数组和类数组结构，将其拆为参数序列  



## eg  
拆数组  
```
let arr1 = [1,2,3,4]
let arr2 = [5,6,7]
console.log([...arr1,...arr2])//将arr1,arr2由...拓展运算符拆为参数序列，再合并为一个数组  
```

拆对象  
```
let obj1 = {name:"a"}
let obj2 = {gender:"1"}
console.log({...obj1,...obj2})
//{name:"a",gender:"1"}
```




# 模板字符串  
## 说明
包裹在``反引号之间的内容，可以作为普通字符串使用 也可以用来定义多行字符串，或者在字符串中嵌入变量，使用模板字符串则不需要拼接字符  
```
`模板字符串内容`
```


## 模板字符串中书写变量  
```
${}
```


# 函数参数的默认值  
## 说明  
直接将默认值写在函数形参数后面即可  
## 语法Eg  
```
function fn(x=7) {
    console.log(x)
}
fn()//没有传递实参则采用默认值,  7
fn(9)//传递实参， 9
```
## <font style="color:red">注意</font>  
- 参数变量是默认声明的，所以不能用let或const再次声明   
- 使用参数默认值时，函数不能有同名参数  
- 参数默认值不是传值的，而是每次都重新计算默认值表达式的值  



# 箭头函数 
## 说明
使用箭头`() => {}`定义函数  
## 语法 
```javascript
var fn = (parameter1,parameter2) => {function statement}
//ES5中为  
//  function fn(parameter1,parameter2) {
//      function statement
//  }
```


## Eg  
当函数需要直接返回一个值(表达式)时可以直接省略大花括号，当函数形参只有一个时可以省略小括号  
```
// function fn(x) {
//    return x
// }
let fn = x => x;
console.log(fn(10)) //输出结果 10
```

## <font style="color:red">注意</font>  
若需要返回一个对象时，需要再对象外层加上小括号避免歧义  
```
var fn = (parameter1,parameter2) => ({key:value,key:value})
```


## 箭头函数中this指向问题  
### 说明
箭头函数中this指向：谁创建箭头函数就指向谁  
### Eg  
```
function Timer() {
  this.s1 = 0;
  this.s2 = 0;
  // 箭头函数
  setInterval(() => this.s1++, 1000);
  // 普通函数
  setInterval(function () {
    this.s2++;
  }, 1000);
}

var timer = new Timer(); 
/* 
创建Timer实例，此时箭头函数创建,普通函数
是window方法，由window调用
*/
setTimeout(() => console.log('s1: ', timer.s1), 3100); // 3
setTimeout(() => console.log('s2: ', timer.s2), 3100); // 0
```

## 箭头函数不适用场景  
1. 自定义对象方法时，对象不构成单独作用域，箭头函数中的this会指向全局作用域  
2. 需要使用动态this时，不应该使用箭头函数  
3. 若函数体比较复杂，多行或函数内部有大量读写操作，不单纯为了计算值，也不应该使用箭头函数

ES6-数组、字符串和函数的扩展

# 说明  
## ES6支持简写对象  
当对象中属性值采用变量且变量名与属性名一致时，可以简写为一个  



```
var a = 18;
var obj = {
    name:"李四",
    age:age
}

//简写为
var obj = {
    name:"李四",
    age
}
```


当对象中属性值为匿名函数时可以省略冒号和function
```
var b = 2;
var obj = {
  a: "1",
  b,
  c: function () {
      return 3
  }
}
//简写为
var obj = {
  a: "1",
  b,
  c() {
      return 3
  }
}
```

ES6-对象的简写

# 说明

本质上是“模式匹配”，等号左右两边的模式相同，右边的值就会赋给左边的变量



# 数组（变量）的解构赋值

模式匹配，变量取值按顺序从左至右匹配，解构不成功则值为undefined

    let [valuename1,valuename2] = [value1,value2]

# 对象的解构赋值

按照变量名匹配对象中的属性名，解构不成功的值为undefined

    let {valuename1,valuename2} = {valuename1:value1,valuename2:value2}

使用Eg

    let information = {name:"张三",age:"18",gender:"男"}
    function fn({name,age}) {
    //函数fn()的参数{name,age}在传入参数时会被解构为name,age
        console.log(name,age)
    }
    fn(information)//传递一个对象

## 嵌套对象的解构

使用冒号意味着解构等号右侧中某个对象的某些东西\
Eg

    let information = {name:"张三",age:"18",gender:"男",hobby:{movie:"run",interest:"computer"}}
    let {hobby:{interest}} = information

此时hobby未被解构