浅谈ES6

ECMAScript6.0（简称ES6）是javaScript语言的下一代标准，已经在2015年6月正式发布了。它的目标，使得javaScript语言可以用来编写复杂的大型应用程序，成为企业级开发语言。各大浏览器的最新版本，随着时间的推移，支持度已经越来越高了，ES6的大部分特性都实现了。那么也就意味着低版本浏览器是不支持ES6的。

本次我会从以下十点来做讲解：

一、let 和 const

二、变量解构赋值

三、字符串扩展

四、数值扩展

五、数组扩展

六、函数扩展

七、对象扩展

八、Set 和 Map结构

九、Generator 生成器函数

十、class写法

一、let 和 const

1、let可以声明变量

let name = '张三';
console.log(name);//张三

2、ES6新增块级作用域

　　注：在ES6之前作用域分为：全局作用域、函数作用域

{
    var name1 = '张三';
    let name2 = '李四';
    console.log(name2);//李四
}
console.log(name1);//张三
console.log(name2);//报错

　　上面代码在代码块之中，分别用let和var声明了两个变量。然后在代码块之外调用这两个变量，结果let声明的变量报错，var声明的变量返回了正确的值。而在代码块内let声明的变量返回了正确的值。这表明，let声明的变量只在它所在的代码块有效。

3、let的使用场景

var a =[];
for(var i=0;i<10;i++){
    a[i] = function(){
        console.log(i);
    }
}
a[6]();//

　　上面的代码中，变量i是var声明的，在全局范围内都有效。所以每一次循环，新的i值都会覆盖旧值，导致最后输出的是最后一轮的i的值。

var a = [];
for(let i=0;i<10;i++){
    a[i]=function(){
        console.log(i);
    }
}
a[6]();//

　　上面代码中，变量i是let声明的，声明的变量仅在块级作用域内有效，当前的i只在本轮循环有效，所以每一次循环的i其实都是一个新的变量，最后输出的是6.

4、不存在变量提升

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

var a = 2;//undefined
let b = 3;//报错

　　上面代码中，变量a用var命令声明，会发生变量提升，即脚本运行时，变量a已经存在了，但是么有值，所以会输出undefined。变量b用let命令声明，不会发生变量提升。这表明在声明它之前，变量b是不存在的，这时如果用到它，就会抛出一个错误。

5、暂时性死区

let b = 3
{
    b=4
}
console.log(b);//

　　当代码执行到代码块中时，b=4在代码块中是没有定义的，所以它会往外找定义的变量，找到let b=3;那么b=4就会覆盖b=3，所以最后 b=4

let b=3
{
    b=4;
    let b=5;
}
console.log(b);//报错

　　上面代码中，存在全局变量b，但是块级作用域内又声明了一个局部变量b，导致后者绑定这个块级作用域，不会再向块区外面找，所以在let声明变量前，对b赋值就会报错。暂时性死区的本质就是，只要一进入当前作用域，所要使用的变量就已经存在了，但是不可获取，只有等到声明变量的那一行代码出现，才可以获取和使用该变量。

　　ES6明确规定，如果区块中存在let和const命令，这个区块对这些命令声明的变量，从一开始就形成看封闭作用域。凡是在声明之前就使用这些变量，就会报错。总之，在代码块内，使用let命令声明变量之前，该变量都是不可用的。在语法上，称为“暂时性死区”。

6、不允许重复声明

{
    let a = 10;
    let a = 8;
    console.log(a);//报错
}

　　let不允许在相同的作用域内重复声明同一个变量。

7、顶层对象属性

var a = 2;
console.log(window.a);//

let b = 3;
console.log(window.b);//undefined

　　顶层对象，在浏览器环境指的是window对象，在Node指的是global对象。ES5之中，顶层对象的属性与全局变量是等价的。

　　ES6规定，var命令和function命令声明的全局变量，依旧是顶层对象的属性;let命令、const命令、class命令声明的全局变量、不属于顶层对象属性。 所以上面代码中，全局变量b是由let声明 ，不是顶层对象，返回undefined。

8、const

　　上面介绍 let 有的属性，const 都有;唯一的区别是const声明的变量是不可以修改的，const声明一个只读的常量，一旦声明，常量的值就不能改变。

const a =2;
a=3;
console.log(a);//报错

　　const特殊的场景

const a ={name:'张三'};
a.name = '李四';
console.log(a);//李四

　　上面代码中，常量a储存的是一个地址，这个地址指向一个对象，不可变的只是这个地址，即不能把a指向另一个地址，但对象本身是可变的。

二、变量解构赋值

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

1、模式匹配

　　模式匹配：只要等号俩边的模式相同，左边的变量就会被赋予对应的值。下面是解构列子

let [foo,[[bar],baz]]=[1,[[2],3]];
console.log(foo);//
console.log(bar);//
console.log(baz);//

let [ , , third]=['a','b','c'];
console.log(third);//c

let [x, ,y]=[5,6,7];
console.log(x);//
console.log(y);//

let [head,...tail]=[1,2,3,4];
console.log(head);//
console.log(tail);//[2, 3, 4]

let [k,j,...z]=['a'];
console.log(k);//a
console.log(j);//undefined
console.log(z);//[]
//注：如果解构不成功，变量的值就等于undefined。

2、不完全解构

　　即等号左边的模式，只匹配一部分的等号右边的数组，这种情况下，解构依然可以成功。

let [x,y]=[1,2,3];
x //
y //

let [a,[b],c]=[1,[2,3],4];
a//
b//
c//
//注：var，let,const命令都适用解构赋值

3、默认值

[x,y='b']=['a'];
console.log(x);//a
console.log(y);//b
//解构赋值允许指定默认值

4、对象解构赋值

var {foo,bar}={foo:'aaa',bar:'bbb'};
console.log(foo);//aaa
console.log(bar);//bbb

　　注：对象解构与数组有一个重要的不同。数组的元素是按次序排列的，变量的取值由它的位置决定;而对象的属性没有次序，变量必须与属性同名，才能取到正确的值。对象解构也可以指定默认值。

5、函数参数解构赋值

function add([x,y]){
    return x+y;
}
add([1,2]);//

　　上面代码中，函数add的参数表面上是一个数组，但在传入参数的那一刻，数组参数就被解构成变量x和y。对于函数内部的代码来说，它们能感受的参数就是X和Y。

//函数参数的解构也可以使用默认值
function move({x=0,y=0}={}){
    return [x,y];
}
move({x:3,y:8});//[3,8]
move({x:3});//[3,0]
move({});//[0,0]
move();//[0,0]

　　上面代码中，函数move的参数就是一个对象，通过对这个对象就行解构，得到变量x和y的值，如果解构失败，x和y等于默认值。

三、字符串扩展

1、for...of循环遍历

var str ='html';
for(let i of str){
    console.log(i);
}
//h
//t
//m
//l
//for of遍历将字符串每个字符都遍历出来了

2、includes()、startsWith()、endsWith()

　　includes():返回布尔值，表示是否找到了参数字符串。
　　startsWith():返回布尔值，表示参数字符串是否在源字符串的头部。
　　endsWith():返回布尔值，表示参数字符串是否在源字符串的尾部。

var str = 'Hello world!';
str.stsrtsWith('world',6)//true
str.endsWith('Hello',5)//true
str.includes('Hello',6)//false

　　上面代码表示，使用第二个参数n时，endsWith的行为与其他俩个方法有所不同，它针对前n个字符，而其他俩个方法针对从第n个位置直到字符串结束。

3、repeat()

//repeat方法返回一个新字符串，表示将原字符串重复n次。
'x'.repeat(3);//'xxx'
'hello'.repeat(2);//'hellohello'

4、模板字符串

　　模板字符串：是增强版的字符串，用反引号(`)标识，它可以当作普通字符串使用，也可以用来定义多行字符串，或者在字符串中嵌入变量，模板字符串中嵌入变量，需要将变量名写在${}之中。

var name ='Bob',time='today';
`hello ${name},how are you ${time}?`

四、数值扩展

1、二进制和八进制的表示法

　　ES6提供了二进制和八进制数值的新写法，分别用前缀0b和0o表示。

2、Number.isNaN()、Number.parseInt()、Number.parseFloat()

//Number.isNaN()用来检查一个值是否为NaN
Number.isNaN(NaN);//true
Number.isNaN(15);//false
Number.isNaN('15');//false
console.log(Number.isNaN(true));//false
//它们与传统的全局方法isNaN()的区别在于，传统方法先调用Number()将非数值的值转为数值，再进行判断，而该新方法只对数值有效，非数值一律返回false.

　　

//ES6将全局方法parseInt()和parseFloat(),移植到Number对象上面，行为完全保持不变。
//ES5写法
parseInt('12.34');//
parseFloat('16.88#');//16.88

//ES6写法
Number.parseInt('12.34');//
Number.parseFloat('16.88#');//16.88
//这样做的目的，是逐步减少全局性方法，使得语言逐步模块化

3、Math对象的扩展

　　Math.trunc():去除一个数的小数部分，返回整数部分

Math.trunc(4.1);//
Math.trunc(4.9);//
Math.trunc(NaN);//NaN
Math.trunc('foo');//NaN
Math.trunc();//NaN
//对于非数值，Math.trunc内部使用Number方法将其先转为数值，对于空值和无法截取整数的值，返回NaN.

　　

　　Math.sign():用来判断一个数到底是正说、负数、还是零。

// 它会返回五中值：参数为正数，返回1；参数为负数，返回-1；参数为0，返回0；参数为-0，返回-0；其他值，返回NaN.
Math.sign(-5);//-1
Math.sign(5);//+1
Math.sign(0);//+0
Math.sign(-0);//-0
Math.sign(NaN);//NaN
Math.sign('foo');//NaN

　　

　　Math.cbrt():用于计算一个数的立方根

Math.cbrt(8);//
Math.cbrt('27');//
Math.cbrt('hello');//NaN
//对于非数值，Math.cbrt方法也是先使用Number方法将其转为数值。

　　Math.hypot():返回所有参数的平方和的平方根

Math.hypot(3,4);//
Math.hypot(3,'4');//
Math.hypot(3,4,'foo');//NaN
//如果参数不是数值，Math.hypot方法将其转为数值，只要有一个参数无法转为数值，就会返回NaN.

五、数组扩展

1、Array.form()

//Array.form():用于将俩类对象转为真正的数组：类似数组的对象和可遍历的对象
var oList = document.getElementById('list');
var aLi = Array.from(oList.children);
//实际应用中，常见的类似数组的对象是DOM操作返回的NodeList集合，以及函数内部的arguments对象。Array.from都可以将它们转为真正的数组。

2、数组实列find()和findIndex()

　　数组实例的find方法，用于找出第一个符合条件的数组成员。它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。

var arr =[1,5,6,9];
var result = arr.find(function(v){
    if(v>5){
        return true;
    }else{
        return false;
    }
});
console.log(result);//

　　数组实例的findIndex方法的用法与find方法非常类似，返回第一个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回-1。

var arr =[1,5,6,9];
var result = arr.find(function(v){
    if(v>5){
        return true;
    }else{
        return false;
    }
});
console.log(result);//

六、函数扩展

1、函数参数默认值

// ES6允许为函数的参数设置默认值，即直接写在参数定义的后面。
function log(x,y='world'){
    console.log(x,y);
}
log('hello');//hello world
log('hello',china);//hello china
log('hello','')//hello

2、参数变量是默认声明的，不能用let 或const再次声明。

function foo(x=5){
    let x =1;//error
    const x=2;//error
}
// 上面代码中，参数变量x是默认声明的，在函数体中，不能用let或const再次声明，否则会报错。

3、rest参数

　　ES6引入rest参数（形式为“...变量名”），用于获取函数的多余参数，这样就不需要使用arguments对象了。rest参数搭配的变量是一个数组，该变量将多余的参数放入数组中。

function print(a,...b){
    console.log(a,b);
}

print(4,5,6,7,8,);//4,[5,6,7,8]

4、扩展运算符

//扩展运算符：扩展运算符（spread）是三个点（...）。它好比rest参数的逆运算，将一个数组转为用逗号分隔的参数序列。
console.log(...[1,2,3]);//1 2 3
console.log(1,...[2,3,4],5);//1 2 3 4 5

//扩展运算符应用一
// 合并数组

[1,2].concat(more);//ES5
[1,2,...more];//ES6
var arr1 = ['a','b'];
var arr2 = ['c'];
var arr3 = ['d','e'];

//ES5的合并数组
arr1.concat(arr2,arr3);//['a','b','c','d','e']
//ES6的合并数组
[...arr1,...arr2,...arr3];//['a','b','c','d','e'] 

//扩展运算符应用二
//与解构赋值结合
const[first,...rest]=[1,2,3,4,5];
first//
rest//[2,3,4,5]

// 如果将扩展运算符用于数组赋值，只能放在参数的最后一位，否则会报错。
const[...first,last]=[1,2,3,4,5];//报错
const[first,...middle,last]=[1,2,3,4,5];//报错

//扩展运算符应用二
//字符串：扩展运算符还可以将字符串转为真正的数组。
[...'hello']//['h','e','l','l','o']

5、严格模式

　　从ES5开始，函数内部可以设定为严格模式。《ECMAScript 2016标准》做了一点修改，规定只要函数参数使用了默认值、解构赋值、或者扩展运算符，那么函数内部就不能显式设定为严格模式，否则会报错。

6、箭头函数

//ES6允许使用“箭头”（=>）定义函数
var f = v =>v;
// 上面的箭头函数等同于
var f = function(v){
    return v;
}

//如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。
var sum =(num1,num2)=>num1+num2;
//等同于
var sum =function(num1,num2){
    return num1+num2;
}

// this在箭头函数中的使用
1：在普通函数中，this指向的是window，在严格模式下，this指向的是undefined
2：在方法内，this指向的是方法的拥有者
3：在箭头函数内，this指向的是创建箭头函数时所在的环境中this指向的值。

七、对象扩展

1、属性的简洁表示法

//ES6允许直接写入变量和函数，作为对象的属性和方法。这样的书写更加简洁
function f(x,y){
    return{x,y};
}
//等同于
function f(x,y){
    return{x:x,y:y};
}
f(1,2);//{x:1,y:2}

2、Object.assign()

//用于对象的合并，将源对象（source）的所有属性，复制到目标对象（target）
var target ={a:1};
var sourcel={b:2};
var sourde2={c:3};
Object.assign(target,sourcel,sourde2);
target //{a:1,b:2,c:3}

　　Object.assign方法的第一个参数是目标对象，后面的参数都是源对象。注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。

八、Set和Map

1、Set

　　ES6提供了新的数据结构Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。Set本身是一个构造函数，用来生成Set数据结构。

var oSet = new Set([1,3,7]);
oSet.add(4);
oSet.add(7);
console.log(oSet);

// 数组去重
var arr = [1,4,5,7,7,5,4,1];
// (方法一)Array.from方法可以将Set结构转为数组
console.log(Array.from(new Set(arr)));
// (方法二)
console.log([...new Set(arr)]);

　

　  Set实例属性

// constructor属性：构造函数，默认就是Set函数。
// size属性：返回Set实例的成员总数。
var oSet = new Set([2,5,8]);
console.log(oSet.constructor);
console.log(oSet.size);

　　Set实列方法

　　Set实例的方法分为两大类：操作方法（用于操作数据）和遍历方法（用于遍历成员）。

//(操作方法)
//add(value)：添加某个值，返回Set结构本身。
//delete(value)：删除某个值，返回一个布尔值，表示删除是否成功
//has(value)：返回一个布尔值，表示该值是否为Set的成员。
//clear()：清除所有成员，没有返回值。

//(遍历方法)
//keys()，values()，entries()：keys方法、values方法、entries方法返回的都是遍历器对象。
//由于 Set 结构没有键名，只有键值（或者说键名和键值是同一个值），所以keys方法和values方法的行为完全一致。
let set = new Set(['red','green','blue']);

for(let item of set.keys()){
    console.log(item);
}
// red
// green
// blue

for(let item of set.values()){
    console.log(item);
}
// red
// green
// blue

for(let item of set.entries()){
    console.log(item);
}
//['red','red']
//['green','green']
//['blue','blue']
//上面代码中，entries方法返回的遍历器，同时包括键名和键值，所以每次输出一个数组，它的两个成员完全相等。

2、Map

　　JavaScript的对象（Object），本质上是键值对的集合，但是传统上只能用字符串当作键。这给它的使用带来了很大的限制。为了解决这个问题，ES6提供了Map数据结构。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object结构提供了“字符串—值”的对应，Map结构提供了“值—值”的对应。如果你需要“键值对”的数据结构，Map比Object更合适

var o = new Map();
o.set('name','张三')；
o.set('function(){}','567');

　　

　　Map实列的属性和方法　

//size属性：返回Map结构的成员总数。
//set(key, value)：set方法设置key所对应的键值，然后返回整个Map结构。如果key已经有值，则键值会被更新，否则就新生成该键。set方法返回的是Map本身，因此可以采用链式写法。
//get(key)：get方法读取key对应的键值，如果找不到key，返回undefined
//has(key)：返回一个布尔值，表示某个键是否在Map数据结构中。
//delete(key)：删除某个键，返回true。如果删除失败，返回false。
//clear()：清除所有成员，没有返回值。

九、Gennerator生成器

　　Generator函数是ES6提供的一种异步编程解决方案，语法行为与传统函数完全不同。从语法上，可以把它理解成，Generator函数是一个状态机，封装了多个内部状态。形式上，Generator函数是一个普通函数，但是有两个特征。一是，function关键字与函数名之间有一个星号；二是，函数体内部使用yield语句，定义不同的内部状态（yield语句在英语里的意思就是“产出”）。执行Generator函数会返回一个遍历器对象，也就是说，Generator函数除了状态机，还是一个遍历器对象生成函数。返回的遍历器对象，可以依次遍历Generator函数内部的每一个状态。

//generator生成器函数
function* sum(a,b){
    var c = a + b;
    yield c;
    var d = c + a;
    yield d;
    var e = d + b;
    yield e;
    var f = c + d +e;
    return f;
}
var o = sum(4,7);
console.log(o.next());//{value: 11, done: false}
console.log(o.next());//{value: 15, done: false}
console.log(o.next());//{value: 22, done: false}
console.log(o.next());//{value: 48, done: true}
console.log(o.next());//{value: undefined, done: true}

　　上面代码中的next方法，是使得指针移向下一个状态。也就是说，每次调用next方法，内部指针就从函数头部或上一次停下来的地方开始执行，直到遇到下一个yield语句（或return语句）为止。换言之，Generator函数是分段执行的，yield语句是暂停执行的标记，而next方法可以恢复执行。

　　yield语句：由于Generator函数返回的遍历器对象，只有调用next方法才会遍历下一个内部状态，所以其实提供了一种可以暂停执行的函数。yield语句就是暂停标志。
遍历器对象的next方法的运行逻辑如下：
　　1：遇到yield语句，就暂停执行后面的操作，并将紧跟在yield后面的那个表达式的值，作为返回的对象的value属性值。
　　2：下一次调用next方法时，再继续往下执行，直到遇到下一个yield语句。
　　3：如果没有再遇到新的yield语句，就一直运行到函数结束，直到return语句为止，并将return语句后面的表达式的值，作为返回的对象的value属性值。
　　4：如果该函数没有return语句，则返回的对象的value属性值为undefined。

　next()方法：会执行generator的代码，然后，每次遇到yield x;就返回一个对象{value: x, done: true/false}，然后“暂停”。返回的value就是yield的返回值，done表示这个generator是否已经执行结束了。如果done为true，则value就是return的返回值。当执行到done为true时，这个generator对象就已经全部执行完毕，不要再继续调用next()了。

十、class的写法

　　俗话说物以类聚人以群分，具有一定的共同属性或特点的，就是calss来定义的类。

// 定义一个类
class Dog{
    constructor(name,age){
        this.name = name;
        this.age  = age;
    }
    bark(){
        console.log('旺旺！')
    }
}
var oDaHuang = new Dog('大黄',3);
var oWangCai = new Dog('旺财',4);

console.log(oDaHuang);
console.log(oWangCai);

oDaHuang.bark();
oWangCai.bark();
// 上面代码表明，类的数据类型就是函数，类本身就指向构造函数。
// 使用的时候，也是直接对类使用new命令，跟构造函数的用法完全一致
// constructor方法：是类的默认方法，通过new命令生成对象实例时，自动调用该方法。一个类必须有constructor方法，如果没有显式定义，一个空的constructor方法会被默认添加。

　　

　　类的继承

//Class之间可以通过extends关键字实现继承
// 下面代码定义了一个类Dog，该类通过extends关键字，继承了Animal类的所有属性和方法。

class Animal {
    constructor() {
        this.legs = 4;
    }
    eat() {
        console.log('吃东西！');
    }
}

class Dog extends Animal{
    constructor(name, age) {
        super();
        // uper作为对象时，指向父类的原型对象。
        this.name = name;
        this.age  = age;
    }
    bark() {
        super.eat();
        // super作为函数调用时，代表父类的构造函数。
        console.log('啊呜！');
    }
    sleep() {
        console.log('睡觉！');
    }
}

var oDaHuang = new Dog('大黄', 3);
var oWangCai = new Dog('旺财', 4);

oDaHuang.bark();

console.log(oDaHuang);
// {legs: 4, name: "大黄", age: 3}
console.log(oWangCai);
//{legs: 4, name: "旺财", age: 4}

　　

　　super关键字：既可以当作函数使用，也可以当作对象使用。在这两种情况下，它的用法完全不同。

　　第一种情况，super作为函数调用时，代表父类的构造函数。ES6 要求，子类的构造函数必须执行一次super函数。

　　注：作为函数时，super()只能用在子类的构造函数之中，用在其他地方就会报错

　　第二种情况，super作为对象时，指向父类的原型对象。

　　知识渊博，认知有限，欢迎各位好友留言指点，互相学习，共同进步。