ES6新特性

1let和const：

作用域： 全局，函数， eval（只有在ES5的严格模式才会出现）

const定义常量与使用let 定义的变量相似：

• 二者都是块级作用域
• 都不能和它所在作用域内的其他变量或函数拥有相同的名称

两者还有以下两点区别：

• const声明的常量必须初始化，而let声明的变量可以不用初始化
• const 定义常量的值不能通过再赋值修改，也不能再次声明，但是它定义的对象和数组可以通过属性值或索引改变。而 let 定义的变量值可以修改。这是因为关键字 const 有一定的误导性。它没有定义常量值。const定义了对值的常量引用。因此，我们不能更改常量原始值，但我们可以更改常量对象的属性。

var和let在函数体内使用，它们在作用域都是局部的；

var和let在函数体外或代码块外使用，它们的作用域都是全局的；

代码提升：var声明的变量会提升到顶端，即可以在声明变量之前就使用它，但是使用时它不会被初始化，它的值是undefined。

通过let或const定义的变量不会被提升到顶端，在声明let或const变量之前就使用它会导致ReferenceError。

 

let不影响作用域链： let定义的变量，如果某作用域内没有该变量的定义和声明，那它会向外层去找let的定义，在循环中非常适用，而var不行，var定义循环的值会不受作用域的影响，从而影响每次变量的值的调用。

 

2.解构赋值

ES6允许按照一定模式从数组和对象中提取值，对变量进行赋值，这被称为解构赋值

数组的比较简单。

对于对象的解构赋值：它的解构赋值名字必须和对象中的属性名相同。

如上面的xiaopin就是相同的才可以解构赋值。

 

3.引入新的声明字符串的方式：``反引号

 

 主要方便了变量的拼接：  记得要在``中使用{}来将变量放在其中。 

 

4.ES6简化了对象的定义方法：

 

 比如上面的improve方法，原来是improve ：function（）｛｝， 省略了：function ，书写更加方便了

 

5箭头函数  （=>） 等于号和大于号的结合体 

ES6允许使用箭头来定义函数；

使用箭头函数，this是静态的，它始终指向函数在声明时所在作用域下的this的值，所以使用call方法调用时，它的this值并不改变。 最重要的 特点

 

直接调用的值都是 尚硅谷。

call方法调用： 

getName.call(school);// ATGUIGU，因为是getName这个函数调用的，school作为参数，成为了这个调用方法的主体，所以是school的属性name

 getName2.call(school);// 尚硅谷 ，因为在 声明时，getName2是在window作用域中声明的，箭头函数就指向声明时的作用域。

不能作为构造实例化对象；

在箭头函数中不能使用arguments变量；

箭头函数的简写：1 可以省略小括号，当 形参有且只有一个的时候

2可以省略｛｝，当代码体只有一条语句的时候，此时return也必须省略，而且语句的执行结果就是函数的返回值。 

 

 

6ES6允许给函数的形参赋值初始值 

 

 

7rest参数

 

 

 

8扩展运算符

 

 

        //symbol

        let s1 = Symbol();

        let s = Symbol('lala');

        let s2 = Symbol('lala');

        console.log(s === s2) // false

        let s4 = Symbol.for()

        let s5 = Symbol.for('out');

        let s6 = Symbol.for('out')

        let k1 = Symbol.for();

        let k2 = Symbol.for()

        // alert(k1 === k2)  //true

        console.log(s5 === s6) // true

        //  let resu=s1+100;  //error

        //  let res1=s1+'100';//error

        //  let res2=s1>100 ; //error

        //    Symbol 创建对象属性

        //方法1

        let game = {

            name: '俄罗斯方块',

            up: 'shang',

            down: 'xia'

        }

        let methods = {

            up: Symbol(),

            down: Symbol()

        }

        game[methods.up] = function () {

            console.log('我向上')

        }

        game[methods.down] = function () {

            console.log('我立刻向下')

        }

        game[methods.up]();

        //方法2

        let youxi = {

            name: '剧本杀',

            [Symbol('say')]: function () {

                console.log('我发言。')

            },

            [Symbol('tuili')]: function () {

                console.log('我推理。。')

            }

        }

        console.log(youxi);

        //需要自定义遍历数据的时候要想到迭代器

        //迭代器 Iterator是一种接口，为各种不同的数据结构提供统一的访问机制，任何数据结构主要

        //部署了Iterator接口，就可以完成遍历操作。

        // 新的遍历方法： for...of  

        //原理是创建了指针对象，用next调用起始位置，接下来不断调用next方法,

        //指针一直往后移动，直到指到最后一个成员。 每次调用next方法返回一个包含value和done属性的对象。  

        const xiyou = ['唐僧', '孙悟空', '猪八戒', '沙僧', '白龙马']

        for (let v of xiyou) {

            console.log(v)//唐僧, 孙悟空, 猪八戒, 沙僧, 白龙马

        }

        for (let v in xiyou) {

            console.log(v) // 01234

            console.log(xiyou[v])//唐僧, 孙悟空, 猪八戒, 沙僧, 白龙马

        }

        //自定义遍历数据

        const f4 = {

            name: 'EDG',

            player: [

                '777',

                'uzi',

                'Ming',

                'xiaohu',

                'theShy'

            ],

            [Symbol.iterator]() {

                //索引变量

                let index = 0;

                return {

                    next: () => {

                        if (index < this.player.length) {

                            const result = { value: this.player[index], done: false }

                            index++;

                            return result;

                        } else {

                            return { value: undefined, done: true }

                        }

                    }

                }

            }

        }

        for (let v of f4) {

            console.log(v)

        }

 9.promise  用于解决回调地狱

Promise一共有三种状态： 未决定的：pending; 成功：resolved、fulfilled ;失败：rejected

异步编程的新解决方案。多层回调函数的相互嵌套, 就形成了回调地狱, promise就用于解决这个问题.

因为promise支持链式调用即 .then()方法，链式调用就是从上往下的回调，所以解决了回调地狱。

promise.race()只要完成一个异步操作,就会执行下一步的.then操作(赛跑机制)

promise.all() 等所有的异步操作完成后,才会执行下一步的.then操作(等待机制)

async 和await 用来简化promise的异步操作, 而且得到的结果是相应文件的内容了.

 

10.set   集合  typeof是对象

可以将数组转化为这个数据结构，然后会自动去重，再用扩展运算符... 把它转回数组 。

 let arr= [2,3,1,77,77,8,8,2,3,5] 

let newArr=[...new Set(arr)] 

console.log(newArr) // [2,3,1,77,8,5]