关于ecmascript:ES6ES7ES8学习指南

3次阅读

共计 13261 个字符，预计需要花费 34 分钟才能阅读完成。

作者：CrazyCodeBoy
链接：https://www.jianshu.com/p/1ae…

ES 全称 ECMAScript，ECMAScript 是 ECMA 制订的标准化脚本语言。目前 JavaScript 应用的 ECMAScript 版本为 ECMAScript-262。

ECMAScript 规范建设在一些原有的技术上，最为驰名的是 JavaScript (网景) 和 JScript (微软)。它最后由网景的 Brendan Eich 创造，第一次呈现是在网景的 Navigator 2.0 浏览器上。Netscape 2.0 以及微软 Internet Explorer 3.0 后序的所有浏览器上都有它的身影。

理解这些个性，不仅能使咱们的编码更加的符合规范，而且能进步咱们 Coding 的效率。

ES6 的个性比拟多，在 ES5 公布近 6 年（2009-11 至 2015-6）之后才将其标准化。两个公布版本之间时间跨度很大，所以 ES6 中的个性比拟多。

在这里列举几个罕用的：

类
模块化
箭头函数
函数参数默认值
模板字符串
解构赋值
延展操作符
对象属性简写
Promise
Let 与 Const

对相熟 Java，object-c，c# 等纯面向对象语言的开发者来说，都会对 class 有一种非凡的情怀。ES6 引入了 class（类），让 JavaScript 的面向对象编程变得更加简略和易于了解。

 class Animal {
    // 构造函数，实例化的时候将会被调用，如果不指定，那么会有一个不带参数的默认构造函数.
    constructor(name,color) {
      this.name = name;
      this.color = color;
    }
    // toString 是原型对象上的属性
    toString() {console.log('name:' + this.name + ',color:' + this.color);

    }
  }

 var animal = new Animal('dog','white');// 实例化 Animal
 animal.toString();

 console.log(animal.hasOwnProperty('name')); //true
 console.log(animal.hasOwnProperty('toString')); // false
 console.log(animal.__proto__.hasOwnProperty('toString')); // true

 class Cat extends Animal {constructor(action) {
    // 子类必须要在 constructor 中指定 super 函数，否则在新建实例的时候会报错.
    // 如果没有置顶 consructor, 默认带 super 函数的 constructor 将会被增加、super('cat','white');
    this.action = action;
  }
  toString() {console.log(super.toString());
  }
 }

 var cat = new Cat('catch')
 cat.toString();

 // 实例 cat 是 Cat 和 Animal 的实例，和 Es5 完全一致。console.log(cat instanceof Cat); // true
 console.log(cat instanceof Animal); // true

ES5 不反对原生的模块化，在 ES6 中模块作为重要的组成部分被增加进来。模块的性能次要由 export 和 import 组成。每一个模块都有本人独自的作用域，模块之间的互相调用关系是通过 export 来规定模块对外裸露的接口，通过 import 来援用其它模块提供的接口。同时还为模块发明了命名空间，避免函数的命名抵触。

ES6 容许在一个模块中应用 export 来导出多个变量或函数。

导出变量

//test.js
export var name = 'Rainbow'

心得：ES6 不仅反对变量的导出，也反对常量的导出。export const sqrt = Math.sqrt;// 导出常量

ES6 将一个文件视为一个模块，下面的模块通过 export 向外输入了一个变量。一个模块也能够同时往外面输入多个变量。

 //test.js
 var name = 'Rainbow';
 var age = '24';
 export {name, age};

导出函数

// myModule.js
export function myModule(someArg) {return someArg;}

定义好模块的输入当前就能够在另外一个模块通过 import 援用。

import {myModule} from 'myModule';// main.js
import {name,age} from 'test';// test.js

心得: 一条 import 语句能够同时导入默认函数和其它变量。import defaultMethod, {otherMethod} from 'xxx.js';

这是 ES6 中最令人激动的个性之一。=>不只是关键字 function 的简写，它还带来了其它益处。箭头函数与突围它的代码共享同一个 this, 能帮你很好的解决 this 的指向问题。有教训的 JavaScript 开发者都相熟诸如var self = this; 或var that = this这种援用外围 this 的模式。但借助=>，就不须要这种模式了。

箭头函数的箭头 => 之前是一个空括号、单个的参数名、或用括号括起的多个参数名，而箭头之后能够是一个表达式（作为函数的返回值），或者是用花括号括起的函数体（须要自行通过 return 来返回值，否则返回的是 undefined）。

// 箭头函数的例子
()=>1
v=>v+1
(a,b)=>a+b
()=>{alert("foo");
}
e=>{if (e == 0){return 0;}
    return 1000/e;
}

心得：不论是箭头函数还是 bind，每次被执行都返回的是一个新的函数援用，因而如果你还须要函数的援用去做一些别的事件（譬如卸载监听器），那么你必须本人保留这个援用。

谬误的做法

class PauseMenu extends React.Component{componentWillMount(){AppStateIOS.addEventListener('change', this.onAppPaused.bind(this));
    }
    componentWillUnmount(){AppStateIOS.removeEventListener('change', this.onAppPaused.bind(this));
    }
    onAppPaused(event){}}

正确的做法

class PauseMenu extends React.Component{constructor(props){super(props);
        this._onAppPaused = this.onAppPaused.bind(this);
    }
    componentWillMount(){AppStateIOS.addEventListener('change', this._onAppPaused);
    }
    componentWillUnmount(){AppStateIOS.removeEventListener('change', this._onAppPaused);
    }
    onAppPaused(event){}}

除上述的做法外，咱们还能够这样做：

class PauseMenu extends React.Component{componentWillMount(){AppStateIOS.addEventListener('change', this.onAppPaused);
    }
    componentWillUnmount(){AppStateIOS.removeEventListener('change', this.onAppPaused);
    }
    onAppPaused = (event) => {// 把函数间接作为一个 arrow function 的属性来定义，初始化的时候就绑定好了 this 指针}
}

须要留神的是：不论是 bind 还是箭头函数，每次被执行都返回的是一个新的函数援用，因而如果你还须要函数的援用去做一些别的事件（譬如卸载监听器），那么你必须本人保留这个援用。

ES6 反对在定义函数的时候为其设置默认值：

function foo(height = 50, color = 'red')
{// ...}

不应用默认值：

function foo(height, color)
{
    var height = height || 50;
    var color = color || 'red';
    //...
}

这样写个别没问题，但当 参数的布尔值为 false时，就会有问题了。比方，咱们这样调用 foo 函数：

foo(0, "")

因为 0 的布尔值为 false，这样 height 的取值将是 50。同理 color 的取值为‘red’。

所以说，函数参数默认值 不仅能是代码变得更加简洁而且能躲避一些问题。

ES6 反对 模板字符串，使得字符串的拼接更加的简洁、直观。

不应用模板字符串：

var name = 'Your name is' + first + '' + last +'.'

应用模板字符串：

var name = `Your name is ${first} ${last}.`

在 ES6 中通过 ${} 就能够实现字符串的拼接，只须要将变量放在大括号之中。

解构赋值语法是 JavaScript 的一种表达式，能够不便的从数组或者对象中疾速提取值赋给定义的变量。

从数组中获取值并赋值到变量中，变量的程序与数组中对象程序对应。

var foo = ["one", "two", "three", "four"];

var [one, two, three] = foo;
console.log(one); // "one"
console.log(two); // "two"
console.log(three); // "three"

// 如果你要疏忽某些值，你能够依照上面的写法获取你想要的值
var [first, , , last] = foo;
console.log(first); // "one"
console.log(last); // "four"

// 你也能够这样写
var a, b; // 先申明变量

[a, b] = [1, 2];
console.log(a); // 1
console.log(b); // 2

如果没有从数组中的获取到值，你能够为变量设置一个默认值。

var a, b;

[a=5, b=7] = [1];
console.log(a); // 1
console.log(b); // 7

通过解构赋值能够不便的替换两个变量的值。

var a = 1;
var b = 3;

[a, b] = [b, a];
console.log(a); // 3
console.log(b); // 1

const student = {
  name:'Ming',
  age:'18',
  city:'Shanghai'  
};

const {name,age,city} = student;
console.log(name); // "Ming"
console.log(age); // "18"
console.log(city); // "Shanghai"

延展操作符...能够在函数调用 / 数组结构时, 将数组表达式或者 string 在语法层面开展；还能够在结构对象时, 将对象表达式按 key-value 的形式开展。

函数调用：

myFunction(...iterableObj);

数组结构或字符串：

[...iterableObj, '4', ...'hello', 6];

结构对象时, 进行克隆或者属性拷贝（ECMAScript 2018 标准新增个性）：

let objClone = {...obj};

在函数调用时应用延展操作符

function sum(x, y, z) {return x + y + z;}
const numbers = [1, 2, 3];

// 不应用延展操作符
console.log(sum.apply(null, numbers));

// 应用延展操作符
console.log(sum(...numbers));// 6

结构数组

没有开展语法的时候，只能组合应用 push，splice，concat 等办法，来将已有数组元素变成新数组的一部分。有了开展语法, 结构新数组会变得更简略、更优雅：

const stuendts = ['Jine','Tom']; 
const persons = ['Tony',... stuendts,'Aaron','Anna'];
conslog.log(persions)// ["Tony", "Jine", "Tom", "Aaron", "Anna"]

和参数列表的开展相似, ... 在结构字数组时, 能够在任意地位屡次应用。

数组拷贝

var arr = [1, 2, 3];
var arr2 = [...arr]; // 等同于 arr.slice()
arr2.push(4); 
console.log(arr2)//[1, 2, 3, 4]

开展语法和 Object.assign() 行为统一, 执行的都是浅拷贝(只遍历一层)。

连贯多个数组

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
var arr3 = [...arr1, ...arr2];// 将 arr2 中所有元素附加到 arr1 前面并返回
// 等同于
var arr4 = arr1.concat(arr2);

var obj1 = {foo: 'bar', x: 42};
var obj2 = {foo: 'baz', y: 13};

var clonedObj = {...obj1};
// 克隆后的对象: {foo: "bar", x: 42}

var mergedObj = {...obj1, ...obj2};
// 合并后的对象: {foo: "baz", x: 42, y: 13}

通常咱们在封装一个组件时，会对外公开一些 props 用于实现性能。大部分状况下在内部应用都应显示的传递 props。然而当传递大量的 props 时，会十分繁琐，这时咱们能够应用 ...(延展操作符, 用于取出参数对象的所有可遍历属性) 来进行传递。

<CustomComponent name ='Jine' age ={21} />

应用 …，等同于下面的写法

const params = {
        name: 'Jine',
        age: 21
    }

<CustomComponent {...params} />

配合解构赋值防止传入一些不须要的参数

var params = {
    name: '123',
    title: '456',
    type: 'aaa'
}

var {type, ...other} = params;

<CustomComponent type='normal' number={2} {...other} />
// 等同于
<CustomComponent type='normal' number={2} name='123' title='456' />

在 ES6 中容许咱们在设置一个对象的属性的时候不指定属性名。

不应用 ES6

const name='Ming',age='18',city='Shanghai';
        
const student = {
    name:name,
    age:age,
    city:city
};
console.log(student);//{name: "Ming", age: "18", city: "Shanghai"}

对象中必须蕴含属性和值，显得十分冗余。

应用 ES6

const name='Ming',age='18',city='Shanghai';
        
const student = {
    name,
    age,
    city
};
console.log(student);//{name: "Ming", age: "18", city: "Shanghai"}

对象中间接写变量，十分简洁。

Promise 是异步编程的一种解决方案，比传统的解决方案 callback 更加的优雅。它最早由社区提出和实现的，ES6 将其写进了语言规范，对立了用法，原生提供了 Promise 对象。

不应用 ES6

嵌套两个 setTimeout 回调函数：

setTimeout(function()
{console.log('Hello'); // 1 秒后输入 "Hello"
    setTimeout(function()
    {console.log('Hi'); // 2 秒后输入 "Hi"
    }, 1000);
}, 1000);

应用 ES6

var waitSecond = new Promise(function(resolve, reject)
{setTimeout(resolve, 1000);
});

waitSecond
    .then(function()
    {console.log("Hello"); // 1 秒后输入 "Hello"
        return waitSecond;
    })
    .then(function()
    {console.log("Hi"); // 2 秒后输入 "Hi"
    });

下面的的代码应用两个 then 来进行异步编程串行化，防止了回调天堂：

在之前 JS 是没有块级作用域的，const 与 let 填补了这不便的空白，const 与 let 都是块级作用域。

应用 var 定义的变量为函数级作用域：

{var a = 10;}

console.log(a); // 输入 10

应用 let 与 const 定义的变量为块级作用域：

{let a = 10;}

console.log(a); //-1 or Error“ReferenceError: a is not defined”

在 ES6 之后，ES 的公布频率更加频繁，根本每年一次，所以自 ES6 之后，每个新版本的个性的数量就比拟少。

includes()
指数操作符

includes() 函数用来判断一个数组是否蕴含一个指定的值，如果蕴含则返回 true，否则返回false。

includes 函数与 indexOf 函数很类似，上面两个表达式是等价的：

arr.includes(x)
arr.indexOf(x) >= 0

接下来咱们来判断数字中是否蕴含某个元素：

在 ES7 之前的做法

应用 indexOf() 验证数组中是否存在某个元素，这时须要依据返回值是否为 - 1 来判断：

let arr = ['react', 'angular', 'vue'];

if (arr.indexOf('react') !== -1)
{console.log('react 存在');
}

应用 ES7 的 includes()

应用 includes()验证数组中是否存在某个元素，这样更加直观简略：

let arr = ['react', 'angular', 'vue'];

if (arr.includes('react'))
{console.log('react 存在');
}

在 ES7 中引入了指数运算符 **，** 具备与 Math.pow(..) 等效的计算结果。

不应用指数操作符

应用自定义的递归函数 calculateExponent 或者 Math.pow()进行指数运算：

function calculateExponent(base, exponent)
{if (exponent === 1)
    {return base;}
    else
    {return base * calculateExponent(base, exponent - 1);
    }
}

console.log(calculateExponent(2, 10)); // 输入 1024
console.log(Math.pow(2, 10)); // 输入 1024

应用指数操作符

应用指数运算符 **，就像 +、- 等操作符一样：

console.log(2**10);// 输入 1024

async/await
Object.values()
Object.entries()
String padding
函数参数列表结尾容许逗号
Object.getOwnPropertyDescriptors()

浏览器兼容性

在 ES8 中退出了对 async/await 的反对，也就咱们所说的 异步函数 ，这是一个很实用的性能。async/await 将咱们从头痛的回调天堂中解脱进去了，使整个代码看起来很简洁。

应用 async/await 与不应用 async/await 的差异：

login(userName) {return new Promise((resolve, reject) => {setTimeout(() => {resolve('1001');
        }, 600);
    });
}

getData(userId) {return new Promise((resolve, reject) => {setTimeout(() => {if (userId === '1001') {resolve('Success');
            } else {reject('Fail');
            }
        }, 600);
    });
}

// 不应用 async/await ES7
doLogin(userName) {this.login(userName)
        .then(this.getData)
        .then(result => {console.log(result)
        })
}

// 应用 async/await ES8
async doLogin2(userName) {const userId=await this.login(userName);
    const result=await this.getData(userId);
}

this.doLogin()// Success
this.doLogin2()// Success

接下来咱们来看一下 async/await 的几种利用场景。

获取异步函数的返回值

异步函数自身会返回一个 Promise，所以咱们能够通过then 来获取异步函数的返回值。

async function charCountAdd(data1, data2) {const d1=await charCount(data1);
    const d2=await charCount(data2);
    return d1+d2;
}
charCountAdd('Hello','Hi').then(console.log);// 通过 then 获取异步函数的返回值。function charCount(data) {return new Promise((resolve, reject) => {setTimeout(() => {resolve(data.length);
        }, 1000);
    });
}

async/await 在并发场景中的利用

对于上述的例子，咱们调用 await 两次，每次都是期待 1 秒一共是 2 秒，效率比拟低，而且两次 await 的调用并没有依赖关系，那能不能让其并发执行呢，答案是能够的，接下来咱们通过 Promise.all 来实现 await 的并发调用。

async function charCountAdd(data1, data2) {const [d1,d2]=await Promise.all([charCount(data1),charCount(data2)]);
    return d1+d2;
}
charCountAdd('Hello','Hi').then(console.log);
function charCount(data) {return new Promise((resolve, reject) => {setTimeout(() => {resolve(data.length);
        }, 1000);
    });
}

通过上述代码咱们实现了两次 charCount 的并发调用，Promise.all承受的是一个数组，它能够将数组中的 promise 对象并发执行；

async/await 的几种错误处理形式

第一种：捕获整个 async/await 函数的谬误

async function charCountAdd(data1, data2) {const d1=await charCount(data1);
    const d2=await charCount(data2);
    return d1+d2;
}
charCountAdd('Hello','Hi')
    .then(console.log)
    .catch(console.log);// 捕获整个 async/await 函数的谬误
...

这种形式能够捕获整个 charCountAdd 运行过程中呈现的谬误，谬误可能是由 charCountAdd 自身产生的，也可能是由对 data1 的计算中或 data2 的计算中产生的。

第二种：捕获单个的 await 表达式的谬误

async function charCountAdd(data1, data2) {const d1=await charCount(data1)
        .catch(e=>console.log('d1 is null'));
    const d2=await charCount(data2)
        .catch(e=>console.log('d2 is null'));
    return d1+d2;
}
charCountAdd('Hello','Hi').then(console.log);

通过这种形式能够捕获每一个 await 表达式的谬误，如果既要捕获每一个 await 表达式的谬误，又要捕获整个 charCountAdd 函数的谬误，能够在调用 charCountAdd 的时候加个catch。

...
charCountAdd('Hello','Hi')
    .then(console.log)
    .catch(console.log);// 捕获整个 async/await 函数的谬误
...

第三种：同时捕获多个的 await 表达式的谬误

async function charCountAdd(data1, data2) {
    let d1,d2;
    try {d1=await charCount(data1);
        d2=await charCount(data2);
    }catch (e){console.log('d1 is null');
    }
    return d1+d2;
}
charCountAdd('Hello','Hi')
    .then(console.log);

function charCount(data) {return new Promise((resolve, reject) => {setTimeout(() => {resolve(data.length);
        }, 1000);
    });
}

Object.values()是一个与 Object.keys() 相似的新函数，但返回的是 Object 本身属性的所有值，不包含继承的值。

假如咱们要遍历如下对象 obj 的所有值：

const obj = {a: 1, b: 2, c: 3};

不应用 Object.values() :ES7

const vals=Object.keys(obj).map(key=>obj[key]);
console.log(vals);//[1, 2, 3]

应用 Object.values() :ES8

const values=Object.values(obj1);
console.log(values);//[1, 2, 3]

从上述代码中能够看出 Object.values() 为咱们省去了遍历 key，并依据这些 key 获取 value 的步骤。

Object.entries()函数返回一个给定对象本身可枚举属性的键值对的数组。

接下来咱们来遍历上文中的 obj 对象的所有属性的 key 和 value：

不应用 Object.entries() :ES7

Object.keys(obj).forEach(key=>{console.log('key:'+key+'value:'+obj[key]);
})
//key:a value:1
//key:b value:2
//key:c value:3

应用 Object.entries() :ES8

for(let [key,value] of Object.entries(obj1)){console.log(`key: ${key} value:${value}`)
}
//key:a value:1
//key:b value:2
//key:c value:3

在 ES8 中 String 新增了两个实例函数 String.prototype.padStart 和String.prototype.padEnd，容许将空字符串或其余字符串增加到原始字符串的结尾或结尾。

String.padStart(targetLength,[padString])

targetLength: 以后字符串须要填充到的指标长度。如果这个数值小于以后字符串的长度，则返回以后字符串自身。
padString:(可选)填充字符串。如果字符串太长，使填充后的字符串长度超过了指标长度，则只保留最左侧的局部，其余局部会被截断，此参数的缺省值为 ” “。

console.log('0.0'.padStart(4,'10')) //10.0
console.log('0.0'.padStart(20))//                0.00

String.padEnd(targetLength,padString])

targetLength: 以后字符串须要填充到的指标长度。如果这个数值小于以后字符串的长度，则返回以后字符串自身。
padString:(可选) 填充字符串。如果字符串太长，使填充后的字符串长度超过了指标长度，则只保留最左侧的局部，其余局部会被截断，此参数的缺省值为 ” “；

console.log('0.0'.padEnd(4,'0')) //0.00 
console.log('0.0'.padEnd(10,'0'))//0.00000000

这是一个不痛不痒的更新，次要作用是方便使用 git 进行多人合作开发时批改同一个函数缩小不必要的行变更。

不应用 ES8

// 程序员 A
var f = function(a,
  b
   ) {...}

// 程序员 B
var f = function(a,
  b,   // 变更行
  c   // 变更行
   ) {...}

// 程序员 C
var f = function(a,
  b,
  c,   // 变更行
  d   // 变更行
   ) {...}

应用 ES8

// 程序员 A
var f = function(a,
  b,
   ) {...}

// 程序员 B
var f = function(a,
  b,
  c,   // 变更行
   ) {...}

// 程序员 C
var f = function(a,
  b,
  c,
  d,   // 变更行
   ) {...}

Object.getOwnPropertyDescriptors()函数用来获取一个对象的所有本身属性的描述符, 如果没有任何本身属性，则返回空对象。

函数原型：

Object.getOwnPropertyDescriptors(obj)

返回 obj 对象的所有本身属性的描述符，如果没有任何本身属性，则返回空对象。

const obj2 = {
    name: 'Jine',
    get age() { return '18'}
};
Object.getOwnPropertyDescriptors(obj2)
// {
//   age: {
//     configurable: true,
//     enumerable: true,
//     get: function age(){}, //the getter function
//     set: undefined
//   },
//   name: {
//     configurable: true,
//     enumerable: true,
//      value:"Jine",
//      writable:true
//   }
// }

技术更替的车轮始终在后退中，JavaScript 的标准和规范也在一直的制订和欠缺。你会发现 ECMAScript 新版的很多个性曾经是 Typescript，浏览器或其余 polyfills 的一部分，就拿 ES8 的 async/await 来说，它是 2017 年 6 月被纳入 ECMAScript 的，但我在 2016 年的时候就曾经开始应用这个个性了，这些个性通常由 ECMAScript 议员提交，而后会呈现在在将来的某个 ECMAScript 版本中。

MDN
ECMAScript® 2016
ECMAScript® 2016 语言规范
ECMAScript® 2017

ES2020 中 Javascript 10 个你应该晓得的新性能
重温 ES6 外围概念和根本用法

最初，欢送关注我的公众号：前端开发博客，回复加群，一起学习提高。

正文完

ecmascript

发表至： ecmascript

2020-11-09

0

关于ecmascript:let-和-const-命令

关于ecmascript:ES6中的Promise和Generator详解

关于ecmascript:对象的扩展

关于ecmascript:解构

关于ssl证书:公网IP地址和SSL证书可以提升SEO吗

关于ecmascript:ES6ES7ES8学习指南

概述

ES6 的个性

1. 类（class）

2. 模块化(Module)

导出(export)

导入(import)

3. 箭头（Arrow）函数

箭头函数的构造

卸载监听器时的陷阱

4. 函数参数默认值

5. 模板字符串

6. 解构赋值

获取数组中的值

获取对象中的值

7. 延展操作符(Spread operator)

语法

利用场景

在 ECMAScript 2018 中延展操作符减少了对对象的反对

在 React 中的利用

个别状况下咱们应该这样写

8. 对象属性简写

9.Promise

10. 反对 let 与 const

ES7 的个性

1. Array.prototype.includes()

2. 指数操作符

ES8 的个性

1.async/await

async/await 的几种利用场景

2.Object.values()

3.Object.entries

4.String padding

4. 函数参数列表结尾容许逗号

5.Object.getOwnPropertyDescriptors()

总结

参考

相干文章

站内搜索