浅谈ES6

Posted LearningTogether

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了浅谈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]();//10

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

var a = [];
for(let i=0;i<10;i++){
    a[i]=function(){
        console.log(i);
    }
}
a[6]();//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);//4

  当代码执行到代码块中时,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);//2

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);//1
console.log(bar);//2
console.log(baz);//3

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

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

let [head,...tail]=[1,2,3,4];
console.log(head);//1
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 //1
y //2

let [a,[b],c]=[1,[2,3],4];
a//1
b//2
c//4
//注: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]);//3

  上面代码中,函数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‘);//12
parseFloat(‘16.88#‘);//16.88

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

3、Math对象的扩展

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

Math.trunc(4.1);//4
Math.trunc(4.9);//4
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);//2
Math.cbrt(‘27‘);//3
Math.cbrt(‘hello‘);//NaN
//对于非数值,Math.cbrt方法也是先使用Number方法将其转为数值。

 

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

Math.hypot(3,4);//5
Math.hypot(3,‘4‘);//5
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);//6

 

  数组实例的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);//2

 

六、函数扩展

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//1
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作为对象时,指向父类的原型对象。

 

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

  

以上是关于浅谈ES6的主要内容,如果未能解决你的问题,请参考以下文章

浅谈ES6的Object.assign()浅拷贝

ES6浅谈--解构,字符串扩展

浅谈ES6原生Promise

浅谈“sublime中”babel的配置

前后端差异更小了——浅谈ES(ECMAScript)6

浅谈ES6