为什么要再次聊起ECMAScript

结合描述经验,很多开发者并没有理解语言和平台之间的关系。

以javascript为例,我们日常编写的代码,哪些属于语言层面,哪些属于平台层面,这一点,很多人都回答不出来。

在以前,不了解这些一样可以写代码,但是在node平台发展的今天,搞明白这些非常重要。

很多人对ES的理解和掌握程度不尽相同,市面上的资料也比较碎片,很难整理。

所以系统化的学习ECMAScript就显得很有必要。

ECMAScript 与 JavaScript

ECMAScript的发展历程前一章已经介绍,很多人也都耳熟能详,这里不做赘述。

这里只介绍ECMAScript2015的新特性和ES2015+的新特性。

整体对ECMAScript有一个认识,建立一个知识体系

ECMAScript是一门脚本语言,通常看作是JavaScript的标准规范。

实际上JavaScript是ECMAScript的扩展语言,ECMAScript只是提供了最基本的预发,通俗点来说只是约定了代码的如何编写,这只是停留在语言层面,并不能完成功能的开发。

而js实现了标准开发,并且做了一定的扩展,使得可以在浏览器环境中操作DOM,BOM;在Node环境可以读写文件。

js本身指的就是ECMAScript + DOM + BOM;

ECMAScript6.0

随着web的发展2015年开始ES保持每年一个版本的迭代。一般都是每年的6月份发行,至今已经发布至ES2020.

ES2015之后ES版本开始按照年份命名,不再按照版本命名,ES6是个特例,一般开发者习惯将ES2015之后的所有版本统称的ES6。

ES2015的重要变化

主要按照下面四个方面来叙述

  1. 解决语法上的一些问题或者不足,比如let,const

  2. 对原有预发进行增强,比如解构赋值

  3. 全新的对象,全新的方法,全新的功能。Object.assign, Promise

  4. 全新的数据类型和数据结构,Symbol, Set, Map

作用域问题

在ES2015之前,只有全局作用域和函数作用域。ES2015新增了块级作用域。使用新关键字let或const声明,区别不var

{
    var i = 3;
}
console.log(i); // 3

使用var声明的i变量,在括号外访问,返回3,由此可见,括号内使用var声明的变量可以被外层访问到

{
    let i = 3;
}
console.log(i); // Uncaught ReferenceError: i is not defined

使用let声明的变量,在括号外访问,抛错,由此可见,括号内使用let声明的变量,不能被外层访问到。

变量提升

所谓变量提升,就是变量可以先访问,后声明,而不会抛错。

console.log(i); // undefined

var i = 123;

使用var 声明的变量存在此问题。而使用let声明的变量,只能先声明后访问,否则跑错

console.log(i); // Uncaught ReferenceError: i is not defined

let i = 123;
重复声明

同一变量名,可以使用var重复声明,使用let或const则只能声明一次.

var a = 1;
var a = 2;
var a = 3;
console.log(a); // 3;
let a = 1;
let a = 2; // Uncaught SyntaxError: Identifier 'a' has already been declared
const 和 let

const 声明的变量不可变值,let声明的变量可以改变。

const只能在声明时赋值,不能先声明后复制

const a = 1;
let b;
b = 2;

const声明的变量仅是不允许修改内存地址,并不是不允许修改成员。

下面是允许的。

const obj = {
    a: 1,
}
obj.a = 2;
// 或者
const arr = [1,2,3];
arr[0] = 4;

模板字符串

ECMAScript2015之前,字符串使用单引号或双引号标明,并且字符串不能换行书写。ES2015新增了模板字符串,使用反引号 ` 声明,并且可以换行书写

const str = `
123
456
`

字符串中可以使用${}使用变量

const name = 'yd';
const age = 18;

const str = `my name is ${name}, I am ${age} years old`;

定义模板字符串的时候可以在前面添加一个函数

const tag = (params, ...args) => {
    // params 第一个参数是一个数组,值为内容分隔过后的数组,不包括参数。
    // 后面参数为字符串中传入的变量
    return params[0] + args[0]; // 返回值为模板字符串的真实值。
}

const str = tag`hello ${'world'}`;

字符串扩展方法

参数默认值

函数参数追加默认值,如果有多个参数,那么带有默认值的参数要放在最后,否则无法正常工作。

ECMAScript2015之前,函数的参数集合使用arguments获取,ES6允许通过…args获取所有参数。该参数只能写在最后,并且只能写一次。

function fn() {
    console.log(arguments); // 参数集合
}

const fn = (...args) => {
    console.log(args); // 参数集合
}

…args代表剩余的参数,假设前面已经有参数接收,…args表示后面未被接收的那些参数。

console.log打印多个值

console.log.apply(console, array); ES5
console.log(...array); ES6

JSON可直接使用变量作为键

const key = 'age';
const obj = {
    [key]: 18
}

Object.is: 判断两个对象是否相等

const a = 123;
const b = 123;
Object.is(a, b); // true

相当于全等于(===), 不同点为可以判断NaN。因为NaN不等于NaN,

NaN === NaN; // false;
Object.is(NaN, NaN); // true;

Proxy

代理,对象拦截

new Proxy(target, {
    get(target, property) {

    },
    set(target, property) {

    },
    deleteProperty(target, property) {

    }
})

区别于Object.definedProperty;

Object.defineProperty只能监听到属性的读写,而Proxy除读写外还可以监听属性的删除,方法对的调用等。

通常我们想要监视数组的变化,基本要依靠重写数组方法,这也是Vue的实现方式,proxy可以直接监视数组的变化。

const list = [1, 2, 3];
const listproxy = new Proxy(list, {
    set(target, property, value) {
        target[property] = value;
        return true; // 标识设置成功
    }
});

list.push(4);

proxy是以非入侵的方式监管了对象的读写,而defineProperty需要按特定的方式定义对象的属性。

Reflect

ECMAScript2015新增的对象,纯静态对象也就是不能被实例画,只能通过静态方法的方式调用,和Math对象类似,只能Math.random(); 调用。

Reflect内部封装了一系列对对象的底层操作,一共14个,其中1个被废弃,还剩下13个,和Proxy
的方法完全一致。

reflect成员方法就是Proxy处理对象的默认实现。

其实Proxy对象默认的方法就是调用了Reflect内部的处理逻辑,也就是如果我们调用get方法,那么在内部,proxy就是将get原封不动的交给了Reflect

const proxy = new Proxy(obj, {
    get(target, property) {
        return Reflect.get(target, property);
    }
})

为什么会有Reflect对象呢,其实他最大的用处就是提供了一套统一操作Object的API

判断对象是否存在某一个属性,可以使用in操作符,但是不优雅,还可以使用Reflect.has(obj, name); 删除一个属性可以使用delete,也可以使用Reflect.deleteProperty(obj, name);

获取所有属性名可以使用Object.keys, 也可以使用Reflect.ownKeys(obj);

Set 和 Map

ECMAScript新增了两种数据结构 Set和Map,

Set类似Array,不同点为存储的内容不能重复

const s = new Set();
s.add(1);
s.add(2);
s.add(1);
console.log(s); // 1, 2

Map类似于json,不同点为json的key只能为字符串,Map的key可以为对象类型

const m = new Map();
m.set('a', 1);
m.set('b', 2);
const key = {};
m.set(key, 3);
console.log(m); // {"a" => 1, "b" => 2, {} => 3}

Symbol

全新的数据类型

在扩展对象的时候,并不知道该对象是否和新扩展的建冲突。在过去我们通过约定命名方式解决这个问题,但是约定并不靠谱,仍旧容易出现冲突的情况。

Symbol是不重复数据

const s = Symbol();
typeof s; // symbol类型

Symbol创建时允许接收一个字符串,作为描述文本, 但也仅是描述作用,相同的描述字段生成的值仍是不同的。

const s1 = Symbol('foo');
const s2 = Symbol('foo');

s1 === s2; // false

对象可以使用Symbol作为属性值。

const name = Symbol();
const person = {
    [name]: 'yd',
    say() {
        return this[name];
    }
}

由于Symbol不重复,所以外部是没办法拿到name字段的。可以使用此方法隐藏内部属性。
Symbol最主要的作用就是为对象添加一个独一无二的属性。

截止到2019标准,ECMAScript一共定义了6种基本数据类型,加上Object一共7种数据类型。
未来还会有BigInt, 目前处于stage-4阶段,所以有八种类型。

Symbol一定是一个唯一的,不论传入的描述是不是相同的,如果想要保存Symbol可以使用全局变量保存,也可以使用Symbol的静态方法for来定义,接收一个字符串作为参数,相同的参数一定对应相同的值,如参数不是字符串,会转换为字符串。

const s1 = Symbol.for('true');
const s2 = Symbol.for(true);

s1 === s2; // true

这个方法维护了一个全局的注册表,为字符串和Symbol提供了一个对应关系。

对象的toString方法挂载Symbol键上

const obj = {};
obj.toString(); // [object object];

const obj = {
    [Symbol.toStringTag]: 'test'
}
obj.toString(); // [object test];

对象的Symbol类型key不会被for in 和 Object.keys遍历出来,也不会出现在JSON.stringify中。

可以使用Object.getOwnPropertySymbols(obj); 获取到

Object,keys 只能获取到字符串的属性名
for of 是ECMAScript2015之后新增的遍历方式。未来会最为遍历所有数据结构的统一方式。

const arr = [1, 2, 3, 4];
for (const item of arr) {
    console.log(item); // 1, 2,3,4
    // break; // 终止循环
}

for of 可遍历数组,类数组arguments,set,map

遍历map时可以直接拿到键和值

for of 不能遍历普通对象,只能遍历存在迭代器的对象。

ECMAScript中能够表示有结构的数据类型越来越多

为了提供一种统一的遍历方式,ES2015提供了Iterable接口,意为可迭代的。供for of 使用。

接口就是规格标准,比如任何类型所有toString方法,就是他们有统一的规格标准。

实现Iterable接口就是 for of 使用的前提。

查看数据的Iterable

const arr = [1, 2, 3];
在控制台打印arr可以发现arr的Symbol.iterable属性,是一个函数
const iterable = arr[Symbol.iterable]();
iterable.next(); // 返回一个对象 { value: 1, done: false }

value是当前遍历到的值,done为是否最后一个。

所有被for of 遍历的对象必须包含一个iterable接口

实现iterable接口

const obj = {
    [Symbol.iterable]: function() { // 约定内部存在一个可迭代的iterable方法
        return { // 返回一个对象,对象包含一个next方法。
            next: function() {
                return { // 返回value和done, value 为当前值,done为是否遍历结束
                    value: 'yd',
                    done: true
                }
            }
        }
    }
}

for (const item of obj) {
    console.log(item);
}

因为第一次遍历的时候done就返回了true,表示迭代结束了,所以并不会进入循环体,也就什么都打印不出来。

const obj = {
    store: [1, 2, 3, 4, 5],
    [Symbol.iterable]: function() {
        let index = 0;
        const self = this;
        return {
            next: function() {
                const result = {
                    value: self.store[index],
                    done: index >= self.store.length
                }
                index++;
                return result;
            }
        }
    }
}

for (const item of obj) {
    console.log(item); // 1, 2, 3, 4, 5
}

generator

生成器函数,引入这样一个新特性是为了避免在复杂的异步编程中回调嵌套,提供更好的异步编程解决方案。

function * foo() {

}
const result = foo();
console.log(result.next());

生成器也实现了迭代器能力

生成器函数对应yield关键字配合使用

const * foo() {
    yield 100;
    yield 200;
    yield 300;
}

每调用一次next就会执行一次yield

实现一个发号器

function * createId() {
    let id = 1;
    while(true) {
        yield id++;
    }
}
const id = createId();

id.next().value;

ECMAScript2016

新增了两个实用小功能

数组的include, 检查数组中是否存在某个元素区别于indexOf,indexOf不能查询到数组中的NaN,includes可以。

新增了指数运算符

以前使用指数只能用Math.pow(2, 10); 表示2的10次方。

新语法用两个**表示

2**10; 2的10次方

ECMAScript2017

对Object对象新增三个扩展方法

Object.keys 返回的是所有的键组成的数组,Object.values返回的是所有值组成的数组。

Object.entries 将对象转成数组,每个元素是键值对的数组,可以快速将对象转为Map

const l = Object.entries({a: 1, b: 2});
const m = new Map(l);

Object.getOwnPropertyDescriptors;获取对象的描述信息

Object.assign 复制时,将对象的属性和方法当做普通属性来复制,并不会复制完整的描述信息,比如this等.

const p1 = {
    a: 'y',
    b: 'd',
    get name() {
        return `${a} ${b}`;
    }
}
const p2 = Object.assign({}, p1);
p2.a = 'z';
p2.name; // y d; 发现并没有修改到a的值,是因为this仍旧指向p1

使用 Object.getOwnPropertyDescriptors 获取完整描述信息

const description = Object.getOwnPropertyDescriptors(p1);
const p2 = Object.defineProperty({}, description);
p2.a = 'z';
p2.name; // z d

新增字符串填充功能

'abc'.padEnd(5, '1'); // abc11; 用给定的字符串在尾部拼接到指定长度

'abc'.padStart(5, '1'); // 11abc; 用给定的字符串在首部拼接到指定长度

允许对象和数组在最后添加一个逗号 [1, 2, 3,], {a: 1, b: 2, }

添加 async + await 异步函数。

在函数声明时加入async关键字,则函数会变为异步函数,当使用await调用时,只有等到被await的promise返回,函数才会向下执行。

const as = async () => {
const data = await ajax();
}

ECMAScript2018

ECMAScript2018新增属性允许将对象的剩余属性收集到新对象中

const data = {a: 1, b: 2, c: 3, d: 4};
const {a, b, ...arg} = data;
console.log(arg); // {c: 3, d: 4};

以前该方式可以运用到数组 从 ES 2018 开始也支持对象了。事实上 Map、Set、String 同样支持该能力。

for of 支持异步迭代。
在此之前想要实现异步迭代想要在for of 外层嵌套一个async函数

async function () {
for (const fn of actions) {
await fn();
}
}

ES2018提供了一种新的书写方式。

async function() {
for await (const fn of actions) {
fn();
}
}

ECMAScript2019

JSON 成为 ECMAScript 的完全子集:在以前,行分隔符(\u2028)和段分隔符(\u2029)会导致 JSON.parse 抛出语法错误异常。

ECMAScript优化了这个功能,不再报错。可正常显示。

JSON.stringify也做了改进,对于超出 Unicode 范围的转义序列,JSON.stringify() 会输出未知字符:JSON.stringify('\uDEAD'); // '"�"'

对Function.prototpye.toString()进行修正, 显示更加完善。在以前,返回的内容中 function 关键字和函数名之间的注释,以及函数名和参数列表左括号之间的空格,是不会被显示出来的。ES2019 现在会精确返回这些内容,函数如何定义的,这就会如何显示。

ES2019为数组新增两个函数,Array.prorptype.flat() 和 Array.prorptype.flatMap()。

flat() 用于对数组进行降维,它可以接收一个参数,用于指定降多少维,默认为 1。降维最多降到一维

const array = [1, [2, [3]]]
array.flat() // [1, 2, [3]]
array.flat(1) // [1, 2, [3]],默认降 1 维
array.flat(2) // [1, 2, 3]
array.flat(3) // [1, 2, 3],最多降到一维

flatMap() 允许在对数组进行降维之前,先进行一轮映射,用法和 map() 一样。然后再将映射的结果降低一个维度。可以说 arr.flatMap(fn) 等效于 arr.map(fn).flat(1)。但是根据 MDN的说法,flatMap() 在效率上略胜一筹,谁知道呢。

flatMap() 也可以等效为 reduce() 和 concat() 的组合,下面这个案例来自 MDN,但是……这不是一个 map 就能搞定的事么?

var arr1 = [1, 2, 3, 4];

arr1.flatMap(x => [x * 2]);
// 等价于
arr1.reduce((acc, x) => acc.concat([x * 2]), []);
// [2, 4, 6, 8]

ES2019 为字符串也新增了两个函数:trimStart() 和 trimEnd()。用过字符串trim()的人都知道了,这两个函数各自负责只去掉单边的多余空格。字符串的trim()是两边都去。

从名字就能看出来,这是 Object.entries() 的逆过程。Object.fromEntries(); 可以将数组转化为对象。

Symbol 是 ES2015引入的新的原始类型,通常在创建Symbol时我们会附加一段描述。过去,只有把这个Symbol转成String才能看到这段描述,而且外层还套了个 'Symbol()' 字样。ES2019 为 Symbol 新增了 description 属性,专门用于查看这段描述。

const sym = Symbol('The description');
String(sym) // 'Symbol(The description)'
sym.description // 'The description'

try…catch 的语法大家都很熟悉了,过去,catch 后面必须有一组括号,里面用一个变量(通常叫 e 或者 err)代表错误信息对象。现在这部分是可选的了,如果异常处理部分不需要错误信息,我们可以把它省略,像写 if…else 一样写 try…catch。

try {
  throw new Error('Some Error')
} catch {
  handleError() // 这里没有用到错误信息,可以省略 catch 后面的 (e)。
}

在之前JavaScript中内置的数组排序算法使用的是不稳定的排序算法,也就是说在每一次执行后,对于相同数据来说,它们的相对位置是不一致的。

比如以下这段代码:

var arr1 = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 1, b: 3}, {a: 2, b: 4}, {a: 5, b: 3}];
arr1.sort((a, b) => a.a - b.a);

返回的结果第一次可能是这样的: [{a: 1, b: 2}, {a: 1, b: 3}…]

但是第二次就变成: [{a:1,b:3}, {a:1, b: 2}….]

这就是不稳定排序算法的一些弊端。那么在es2019中,JavaScript内部放弃了不稳定的快排算法,而选择使用Tim Sort这种稳定的排序算法。优化了这个功能。

ECMAScript2020

类的主要目的之一是将代码包含到更可重用的模块中。因为你将创建一个在许多不同地方使用的类,所以你可能不希望它内部的所有内容都是全局可用的。现在,通过在变量或函数前面添加一个简单的哈希符号,我们可以将它们完全保留为类内部使用

class Message {
 #message = "Howdy"
 greet() { console.log(this.#message) }
}

const greeting = new Message()

greeting.greet() // Howdy 内部可以访问
console.log(greeting.#message) // Private name #message is not defined  不能直接被访问

新增Promise.allSettled方法。

当我们处理多个Promise时,特别是当它们相互依赖时,记录每个Promise所发生的事情来调试错误是很有必要的。通过Promise.allSettled,我们可以创建一个新的Promise,它只在所有传递给它的Promise都完成时返回一个数组,其中包含每个Promise的数据。

const p1 = new Promise((res, rej) => setTimeout(res, 1000));

const p2 = new Promise((res, rej) => setTimeout(rej, 1000));

Promise.allSettled([p1, p2]).then(data => console.log(data));

// [
//   Object { status: "fulfilled", value: undefined},
//   Object { status: "rejected", reason: undefined}
// ]

区别于Promise.all方法,Promise.all是当多个promise全部成功,或出现第一个失败就会结束。Promise.allSettled 是所有都执行完成,无论成功失败。

假设变量a不存在,我们希望给系统一个默认值,一般我们会使用 || 运算符。但是在javascript中空字符串,数字0,false都会执行 || 运算符,所以ECMAScript2020引入合并空运算符解决该问题,只允许在值为null或未定义时使用默认值。

const name = '';

console.log(name || 'yd'); // yd;
console.log(name ?? 'yd'); // '';

业务代码中经常会遇到这样的情况,a对象有个属性b, b也是一个对象有个属性c,

const a = {
    b: {
        c: 123,
    }
}

我们需要访问c,经常会写成 a.b.c,但是如果b不存在时,就会出错。

ECMAScript2020定义可选链运算符解决该问题,通过在.之前添加一个?将键名变成可选

let person = {};
console.log(person?.profile?.age ?? 18); // 18

JavaScript可以处理的最大数字是2的53次方 - 1,我们可以在我们可以在 Number.MAX_SAFE_INTEGER 中看到, 更大的数字则无法处理,ECMAScript2020引入BigInt数据类型来解决这个问题。通过把字母n放在末尾, 可以运算大数据。可以通过常规操作(例如算术运算符)进行加、减、乘、除、余数和幂等运算。它可以由数字和十六进制或二进制字符串构造。此外它还支持 AND、OR、NOT 和 XOR 之类的按位运算。唯一无效的位运算是零填充右移运算符。

const bigNum = 100000000000000000000000000000n;
console.log(bigNum * 2n); // 200000000000000000000000000000n

const bigInt = BigInt(1);
console.log(bigInt); // 1n;

const bigInt2 = BigInt('2222222222222222222');
console.log(bigInt2); // 2222222222222222222n;

BigInt是一个大整数,不能存储小数。

动态导入import('./a.js').then

const a = 123;
export { a };
import('./a.js').then(data => {
    console.log(data.a); // 123;
})

提供一种标准化方式访问全局对象,globalThis,在浏览器中window作为全局对象,在node中global作为全局对象,ECMAScript2020提供globalThis作为语言的全局对象,方便代码移植到不同环境中运行。