2020-09-10---ES6

一、严格模式

“use strict”； 注：写在作用域开头

影响：

1. 声明变量必须使用关键字
2. 函数的参数不能重复
3. 函数中的参数的改变不影响arguments中的值
4. 取消了arguments中的callee方法
5. 取消了with解析对象
6. 新增关键字 eval arguments
7. 取消了八进制

二、修改上下文this指向

默认：this指向当前所在的作用域（function/strict）所绑定的对象（当前函数被谁调用了，this就代表谁）

函数的方法：

1. bind（对象，参数1，参数2，……） 返回函数

2. call（对象，参数1，参数2，……） 返回对象

3. apply（对象，数组|arguments） 返回对象

注：参数中的对象，this想要指向哪个对象，就写哪个对象。

三、JSON方法

JSON : 跨平台 跨语言 [] {}

1.JSON.parse() : 将严格的json格式的字符串解析为对象

2.JSON.stringify() ：将对象转为JSON字符串

四、新增关键字 let & const

1.let : 用户声明变量，取代var

1. 声明变量，必须先声明，后使用。变量不再做提升。
2. 在同一个作用域中，不重复声明一个变量。
3. 声明的全局变量不再是window的属性。
4. 产生了块级作用域（注意：for循环本身是一个块级作用域，循环体又是for下面的一个子级块作用域）

2.const :声明常量

注：一次声明，不能重新赋值（栈中的值不能变，堆中的数据可变）（基本数据类型的值不能变。复合数据类型的存储的数据可变，地址不能变）

五、变量的解构赋值

解构 ：分解解构

1.数组的解构赋值

[] = [] 保持两边格式一致，一一对应的赋值

2.对象的解构赋值

{} = {} 保持两边格式一致，可以不一一对应的赋值
好处：

1. 交换数据
2. 函数的形参可以赋默认值
3. 函数的参数可以不按照顺序传递
4. 函数的返回值可以一次返回多个数据

六、字符串扩展方法

1.includes（字符串，start）

返回布尔值，判断是否包含，从start开始向右找

2.startWith（字符串，start）

返回布尔值，判断是否在字符串的开头，从start开始向右找

3.endWith（字符串，start）

返回布尔值，判断是否在字符串的结尾，从start开始向左找

let str = 'how do you do';
console.log(str.includes('do',4));   //true  true
console.log(str.startWith('do',4));   //false  true
console.log(str.endWith('do',4));  //true  false

4.repeat（n）重复字符串

注：1. 如果n是小数，则向下取整重复
2. 如果n是非数字类型，则转为数字，如果不能转，转为NaN，按0次重复
3. 如果n <= -1 报错

5.模板字符串 替换+（连接）

`  ${变量}   `

七、箭头函数

（） => {}
特点

1. 箭头函数中没有this指向
2. 不能创建构造函数，也不能new
3. 如果返回对象，在外面包裹小括号
4. 建议在回调函数中使用

八、Symbol ：ES6新增的一种基本数据类型！可以确保变量中的值是惟一的

基本数据类型：number string boolean null undefined Symbol
复合数据类型：object

九、Set 构造函数 （重复）

1.如何创建set对象

let set = new Set();
let set = new Set([1,4,3,2,2,2,1,1,''1]);   //1,4,3,2,'1'

2.属性

size ： 获取长度

3.方法

（1）add（）：添加元素

（2）has（）：判断一个元素是否在set中

（3）delete（）：删除一个元素

（4）clear（）：清空set对象

4.遍历set对象

    forEach((value,key,set)=>{})
    keys() : 获取所有的key
    values() : 获取所有的value
    entries() : 获取所有的key和value
    
    for of 循环
    for(变量 of set){}

<script>
        let set = new Set();
        set.add(1).add(2).add(3).add(4).add(5);
        console.log(set);

        //遍历set
        set.forEach((value,key,set)=>{
            console.log('value:' + value,'key:' + key,'set:' + set);
        })

        //for of key
        for(let key of set.keys()){
            console.log('key:' + key);
        }
        //for of value
        for(let value of set.values()){
            console.log('value:' + value);
        }
        //for of key value
        for(let [key,value] of set.entries()){
            console.log('key:' + key,'value' + value);
        }


        var arr = [1,23,4,2,2,2,1,1,2,2,3];

        // function arrNoRepeat(arr){
        //     let list = [];
        //     for(let i = 0,len = arr.length;i < len;i ++){
        //         if(list.indexOf(arr[i]) === -1){
        //             list.push(arr[i]);
        //         }
        //     }
        //     return arr;
        // }
        function arrNoRepeat(arr){
            return [...new Set(arr)];
        }
        console.log(arrNoRepeat(arr));
        // var str = 'abcde';
        // var arr = [...str];
        // console.log(arr);
    </script>

十 、Map 构造函数

1.创建map对象

 let map = new Map();

        let map = new Map([
            [1,1],
            ['1',2],
            [true,3],
            [[],4],
            [{},5]
        ]);

2.属性

size：长度

3.方法

set() : 添加map属性
        get() : 获取属性
        has() : 判断是存在指定的属性,返回布尔值
        delete() : 删除属性
        clear() : 清空map

4.遍历map

forEach((value,key,map)=>{})

        keys() : 获取所有key
        values() : 获取所有value
        entries() : 获取所有的key和value

        for of


        let map = new Map();
        console.log(map);
        map.set(1,1).set(2,2).set(3,true).set(4,false).set(true,7);
        // map.clear();
        // console.log(map);
        // console.log(map.get(true));
        // console.log(map.delete(4));
        // console.log(map.has(4));

        //forEach
        map.forEach((value,key,map)=>{
            console.log(value,key,map);
        })

        //key
        for(let key of map.keys()){
            console.log('key:' + key);
        }
        //value
        for(let value of map.values()){
            console.log('value:' + value);
        }
        //key value
        for(let [key,value] of map.entries()){
            console.log('key:' + key,"value:" + value);
        }

十一、生成器函数 ： ES6提出的异步编程解决方案

1. 同步：按步骤依次执行
2. 异步：同时进行

function * fn(){
        yield 'how';
        yield 'are';
        yield 'you';
        return '?';
    }

    let fun = fn();
    console.log(fun.next());  //{value : how ,done : false}  false : 表示后面还有语句待执行. true:表示结束
    console.log(fun.next());
    console.log(fun.next());
    console.log(fun.next());
    console.log(fun.next());
    console.log(fun.next());
    console.log(fun.next());

十二、class 类

class 类名{
	constructor([参数]){
		//属性
		this.属性 = 值；
	}
	方法名([参数]){
		……
	}
}

extends：继承 父类拥有的属性和方法，继承后，子类将拥有

class 子类名 extends 父类名{
	constroctor([参数]){
		super([参数]);
		this.属性 = 值；
	}
	方法名([参数]){
		……
	}
}