es6笔记

symbol

ES5的对象属性名是字符串，这容易造成属性名的冲突。symbol是一种机制，保证每个属性的名字都是独一无二的。这样就从根本上防止属性名冲突。

它是一种原始数据类型Symbol,表示独一无二的值。它属于javaScript语言的原生数据类型之一。其他数据类型是,undefinde,null, 布尔值（Boolean),字符串（String),数值（Number)，大整数（BigInt),对象(object)

symbol值通过symbol（）函数生成。这也就是说，对象的属性名现在可以有两种类型，一种是原来就有的字符串，另一种是新增的Symbol类型。凡是属性名属于Symbol类型，就都是独一无二的，可以保证不会与其他属性名产生冲突

Symbol()函数不能使用new命令 ，否则会报错。这是因为Symbol是一个原始类型的值，不是对象，所以不能用new命令来调用。Symbol值不是对象，所以也不能添加属性。基本上，它是一种类似字符串的数据类型

Symbol（）函数的参数只是对当前Symbol值的描述，因此相同参数的Symbol函数返回值是不相等的

Symbol值不能与其他类型的值进行运算，会报错

Symbol（）函数创建symbol值时，可以用参数添加一个描述

但是读取这个方法要将symbol显示转换为字符串

由于每一个symbol值都是不相等的，这意味着只要symbol值作为标识符，用于对象的属性名，就能保证不会出现同名属性。这对于一个对象由多个模块构成的情况非常有用，能防止某一个键不小心改写覆盖

属性名遍历

symbol值作为属性名，遍历对象的时候，该属性不会出现在for...in,for...of循环中，也不会被object.keys(),object.getownproppertyNames(),json.stringify()返回

但是它也是一个私有属性有一个object.getownPropertysymbols()方法，可以获取指定对象的所有symbol属性名。该方法返回一个数组，成员是当前对象的所有用作属性名的symbol值

reflect.ownkeys()方法阶梯返回所有类型的键名，包括常规键和symbol键名

有时我能希望使用同一个symbol值，symbol.for（）方法可以做到这一点。它接受一个字符串作为参数，然后搜索没有以该参数作为名称的symbol值。如果有，就返回这个symbol值，否则就新建一个以该字符串为名称的symbol值，并将其注册到全局

symbol.for()与symbol()这两种写法都会生成新的symbol。它们的区别是，前者会被登记在全局环境中共搜索，后者不会。symbol.for()不会每次调用就返回一个新的symbol类型的值，而是会先检查给定的key是否已经存在，如果不存在才会新建一个值。

Symbol.keyFor()方法返回一个已登记的symbol类型的key

由于symbol没有登记机制，所以用symbol创建的会返回undefinde

 

Set

ES6提供了新的数据结构set。它类似于数组，但是成员的值都是唯一的，没有重复的值

set本身是一个构造函数，用来生成set数据结构

add()方法用来向set结构内部添加成员，set结构不会添加重复的值  set 函数也可以接收一个数组（或者具有iterable接口的其他数据结构）作为参数，用来初始化

去除数组重复成员的方法

[...new Set(arry)]

去除字符串里面的重复字符

[...new Set('ababb')].join('')

向set加入值的时候，不会发生类型转换，所以5和'5'是两个不相同的值。set内部判断两个值是否不停，使用的算法叫做‘same-value-zero equality' 它类似于精确相等运算符，主要的区别是向set加入值时认为NAN等于自身，而精确运算相等运算符认为NAN不等于自身 另外两个对象是不相等的

set实例的属性和方法

set结构实例有以下属性

set.prototype.consyructor:构造函数，默认就是set函数

set.prototype.size:返回set实例的成员总数

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

set.prototype.add(value):添加某个值，返回set结构本身

set.prototype.delete(value):删除某个值，返回一个布尔值，表示是否成功

set.prototype.has(value)：返回一个布尔值，表示该值是否为set的成员

set.prototype.clear()：清除所有成员，没有返回值

Array.form方法可以将set结构转为数组

这就提供了去除数组重复成员的另一种方法

function dedupe(array){

  return Array.form(new Set(array))

}

遍历操作

SeT结构的实例有四个遍历方法，可以用于遍历成员

Sst.prototype.keys()：返回键名的遍历器

set.prototype.values()返回键值的遍历器

set.prototype.entries()返回键值对的遍历对象

set.prototype.foreach()使用回调函数遍历每个成员

需要特别指出的是，Set的遍历顺序就是插入顺序。这个特性有时非常有用，比如使用set保存一个回调函数列表，调用时就能保证按照添加顺序调用

WeakSet

weakset结构和set结构类似，也是不重复的值的集合。但是它与set有两个区别

首先,weakset的成员只能是对象，而不能是其他类型的值

尝试向weakset添加数值或者是symbol指，都会报错，因为weakset只能放置对象 其次weakset中的对象都是弱引用，即垃圾回收机制不考虑weakset对该对象的引用，也就是说，如果其他对象都不再引用改对象，那么垃圾回收机制会自动回收改对象所占用的内存，不考虑该对象还存在weakset中

weakset不可遍历

 

map

js的对象，本质上使键值对的集合（hash结构），但是传统上只能用字符串来当中键。这给它的使用带来了很大的限制

由于对象只接收字符串作为键名导致的不方便，为了解决这个问题es6提供了map数据结构，它类似于对象，也是键值对的几个，但是键的范围不限于字符串，各种类型的值（包括对象

都可以当做键。也就是说，object结构提供了字符串和值的对象，map结构提供了值和值的对应，是一种更完善的hash结构实现.

事实上，不仅仅是数组，任何具有iterator接口，且每个成员都是一个双元素的数组的数据结构都可以当做map构造函数的参数。这也就是说set可以用来生成新的map

实例属性和操作方法

map结构的实例有以下属性和操作方法

size属性

size属性返回map结构的成员总数

map.prototype.set(key,value)

set方法设置键名key对应的键值为value,然后返回整个map结构。如果key已经有值则键值会被更新，否则就重新生成该键

因为set方法返回的是当前的map对象所以可以采用链式的写法

map.prototype.get(key)

get方法读取key对应的键值，如果找不到key，返回undefinde

map.prototype.has(key)

has方法返回一个布尔值，表示某个键是否在当前的map对象之中

map.prototype.delete(key)

delete方法删除某个键，返回true。如果删除失败返回false

map.prototype.clear()

clear方法清除所有成员，没有返回值

遍历方法

map结构原生提供三个遍历器生成函数和一个遍历方法

map.prototype.keys()：返回键名的遍历器

map.prototype.values():返回键值的遍历器

map.prototype.entries()：返回所有成员的遍历器

map.prototype.foreach():遍历map的所有成员

map转换为数组结构比较快速的方法是使用扩展运算符(...)

[...map.keys()]

[...map.values()]

[...map.entries()]

[...map]

map与其他数据结构的相互转换

数组转为map

将数组作为参数传入map的构造函数，就可以转为map

map转为对象

如果所有的map键都是字符串，它可以无损的转换为对象

如果有非字符串的键名，那么这个键名会被转成字符串，在作为对象的键名

对象转为map

对象转为map可以通过object.entrues(xxx)

proxy

用于修改某些操作的默认行为，，等同于在语言层面做出修改，所以属于一种元编程，即对编程语言进行编程

proxy可以理解成，在目标对象之前架设一层拦截，外界对该对象的访问都必须先经过这层拦截，因此提供了一种机制，可以对外界的访问进行过来吧和改写。proxy这个词的原意是代理，用来表在这里用来表示由他代理某些操作，可以译为代理器

es6原生提供proxy函数，用来生成proxy实例

vat proxy =new Proxy(target,handler)

Proxy对象的所有用法，都是上面的这种形式，不同的只是handler参数的写法。其中，new proxy()表示生成一个proxy实例.target参数表示所要拦截的目标对象。handler参数也是一个对象，用来定制拦截行为

proxy接收两个参数。第一个参数是所要代理的目标对象（如果没有proxy的介入。操作原来要访问的就是这个对象）、第二个参是一个配置对象，对于每一个被代理的操作，需要提供一个对应的处理函数，该函数将拦截对应的操作，需要同一个对应的处理函数，该函数将拦截响应的操作。如果handler函数没有设置任何的拦截，那就等同于直接通向原对象

proxy实例的方法

get()方法用于拦截某个属性的读取操作，可以接受三个参数，依次为目标群对象，属性名和proxy本身（严格的说，是操作行为所针对的对象），其中最后一个参数可选。

set()方法用于拦截某个互相的赋值操作，可以接受4个参数，依次为目标对象，属性名，属性值，和proxy实例本身，其中最后一个参可选

apply（）方法拦截函数的调用，call和apply操作.可以接收三个参数，分别是目标对象，目标对象的上下文对象（this）和目标对象参数

has（）方法用来拦截hasoroperty操作，即判断对象是否具有某个属性时，这个方法会生效（in操作符) has()方法可以接受两个参数，分别是目标对象，需查询的属性名

construct（）方法用于拦截new命令。可以接收三个参数,目标对象，构造函数的参数数租，

创建实例对象时,new命令作用的构造函数

deleteProperty()方法用于拦截delete操作

difineProperty()用来拦截object,defineProperty()操作

getOwnPropertyDescriptor()拦截object.getownPropertyDescriptor()

getPrototypeOF()用来拦截获取对象的原型

isExtensible()方法拦截object.isExtensible()

ownKeys（）方法用来拦截对象自身属性的读取操作

preventExtensions()拦截object.prevwntExtensions()

setPrototypeOf()拦截object.setPrototypeof()

proxy.revocable()方法返回一个可以取消的proxy实例

this.问题。虽然proxy可以代理针对目标对象的访问，但它不是目标对象的透明代理，即不做任何拦截的情况下，也无法保证与目标对象的行为一致。

 

reflect 对象与proxy对象一样，也是ES6为了操作对象而提供的API。

将object.defineProperty，放到reflect对象上。现阶段，某些方法同时在object和refelect对象上部署。未来的新方法都将在reflect对象上部署。也就是说，从reflect对象上介意拿到语言内部的方法

修改某些object方法返回的结果，让其变得更合理

让object操作都变成函数行为

reflect对象的方法与proxy对象的方法一一对应

promise对象

promise是异步编程的一种解决方案，比传统的解决方案--回调函数和事件更合理和更强大。

所谓promise，简单就是一个容器，里面保存这某个未来才会结束的事件（通常就是一个异步操作）的结果。从语法上来说，promise是一个对象，从它可以获取异步操作的消息。promise提供统一的API，各种异步操作都可以用同样的方法进行处理。

promise对象有以下两个特点

1.对象的状态不受外界影响。promise对象代表一个异步操作.有三种状态pending(进行中),fulfilled（已成功)和rejected（已失败)。只有异步操作的结果，可以决定当前是哪一种状态。任何其他操作都无法改变这个状态。这也是promise这个名字的由来。它的英语意思就是承诺。表示其他手段无法改变.

一旦状态改变,就不会再变。任何时候都可以得到这个结果。promise对象的状态改变只有两个可能:从pending变为fullfilled和从pending变成rejected。只要这两种情况发生，状态就凝固了，不会再变了。如果改变已经发生了，你再对promise对象添加回调函数，也会立即得到这个结果。这与事件(event)完全不同，事件的特点是。如果你错过了它，再去监听，是得不到结果的。

ES6规定promise对象是一个构造函数，用来生成promise实例.

promise构造函数接受一个函数作为参数，该函数的两个参数分别是resolve和reject。它们是两个函数，由javascript引擎提供，不用自己部署

resolve函数的作用是,将promise对象从未完成的状态变成成功（即从pending变为resolved），在异步操作成功时调用，并将异步操作的结果，作为参数传递出去。reject函数的作用是，将promise对象的状态从为完成变为失败（即从pending变成rejected）。在异步操作失败时调用，并将异步操作报出的错误，作为参数传递出去

promise实例生成以后，可以用then方法分别指定resolved状态和rejected状态的回调函数

then方法可以接收两个回调函数作为参数。第一个回调函数是promise对象的状态变为resolved时调用.第二个回调函数是promise对象变成rejected时调用.这两个函数都是可选的，不一定要提供。它们都接受promise对象传出的值作为参数

promise实例具有then方法，也就是说.then方法是定义在原型对象上promise.prototype上的.它的作用是为promise实例添加状态改变时的回调函数。前面说过,then方法的第一个参数是resolved状态的回调函数。第二个参数是rejected状态的回调函数，它们都是可选的

then方法返回的是一个新的promise实例(注意，不是原来那个promise实例).因此可以采用链式写法，即then方法后面再调用一个then方法

promise.prototype.catch()方法是.then（null,rejection)或.then(underfined,rejection)的别名，用于指定错误发生时的回调

promise.all（）方法用于将多个promise实例，包装成一个新的promise实例 都成功才返回成功 有一个失败则返回失败

promise.race（）方法同样是将多个promise实例。包装成一个新的promise实例 里面包裹的实例谁跑的最快就用谁的结果

promise.allSettled()用来确定一组异步操作是否都结束了（不管成功或者失败）

promise.any（）一个成功就成功 全部失败才失败

promise.resolve()将现有的对象转换为promise对象

 

js原有的表集合的数据结构。主要是数组（array）和对象(object)。es6又添加了map和set。这样就有了四种数据结构的几个。需要一种统一的接口机制，处理不同的数据结构

遍历器就是这样一种机制。它是一种接口，为各种不同的数据结构提供统一的访问机制。任何数据结构只要部署iterator接口，就可以完成遍历操作（即依次处理该数据结构的所有成员）

interator的作用有三个:

为各种数据结构提供一个统一的，简便的访问接口。51A43E67.png数据结构的成员能够按照某种次序排序.es6创造了一种新的遍历命令for...of循环.iterator接口主要提供for...of消费

interator的遍历过程

创建一个指针对象，指向当前数据结构的起始位置。也就是说，遍历器对象本质上，就是一个指针对象。第一次调用指针对象的next方法，可以将指针指向数据结构的第一个成员。第二次调用指针对象的next方法，指针就向指向数据结构的第二个成员。不断调用指针的对象的next方法，直到它指向的数据结构的结束位置

每一次调用next方法，都会返回数据结构的当前成员的信息。具体来说，就是返回一个包含value和done两个属性的对象。其中,value属性是当前成员的值，done数据是一个布尔值，表示遍历是否结束

默认的iterator接口

iterator接口的目的，就是为所有的数据结构，提供了一种统一的访问机制.即for...of循环.当使用for..of循环遍历某种数据结构时，该循环会自动去寻找iterator接口

一种数据结构只要部署了iterable接口，我们就称这种数据结构是可遍历的

es6规定，默认的iteractor接口部署在数据结构的symbol.iterator属性，或者说，一个数据结构只要具有symbol.iterator属性。就可以认为是可遍历的

(iterable)。symbol.iteractor属性本身是一个函数，就是当前数据结构默认的遍历器生成函数，执行这个函数，就会返回一个遍历器。至于属性名symbol.iterator，它是一个表达式。返回smbol对象的iteartor属性。这是一个预定义好的，类型为symbol的特殊值，所以要放在方括号内

调用iterator接口的场合

有一些场合会默认调用iterator接口（即symbol.iterator方法）

解构赋值

扩展运算符

yield*后面跟的是一个可遍历的结构，它会调用改结构的遍历器接口

for...of

array.form()

map(),set().weakmap(),weakset()

promise.all()

promise.race()

字符串的iterator接口.字符串是一个类似数组的对象，也原生具有iterator接口

遍历器对象具有的方法

遍历器对象除了具有next（）方法，还具有return（）方法（）和throw（）方法。

return（）方法的使用场合是,如果for...of循环提前退出（通常因为出错或者有break语句)。就会调用return方法（）.如果一个对象在完成遍历前，需要清理或者释放资源。就可以部署return（）方法

throw（）方法主要配合generator函数使用，一般的遍历对象用不到这个方法

es6借鉴c++，java，c#和python语言，引入了for..of循环.作为遍历所有数据的统一方法

一个数据结构只要部署了symbol.iterator属性，就被视为具有iterator接口，就可以用for...of循环遍历它的成员，也就是说。for...of循环内部调用的是数据结构的symbol.iterator方法

for...of循环可以使用的范围包括数组，set和map结构,某些类似数组的对象（比如arguments对象,dom nodelist对象）。

gennerator函数是es6提供的一种异步编程解决方案，语法行为与传统函数完全不同。

generator函数有多种理解角度。语法上首先可以理解成,genrator函数是一个状态机，封装了多个内部的状态。

执行genrator函数会返回一个遍历器对象，也就是说，genrator函数处理状态机，还是一个遍历器对象生成函数。返回的遍历器地下，可以依次遍历genrator函数内部的每一个状态

形式上genrator函数是一个普通的函数，但是有两个特征。一是,function关键字与函数名之间有一个星号，二是，函数体内部使用yield表达式，定义不同的内部状态(yield在英语里的意思就是产出)

genrator函数的调用和普通函数一样，也是函数名后面加上一对圆括号。不同的是调用genrator函数后，该函数并不执行，返回的也不是函数运行的结果，而是一个指向内部状态的指针对象，也就是上一章介绍的遍历器对象

必须调用遍历器对象的next（）方法，使得指针移向下一个状态，也就是说每次调用next（）方法，内部指针就从函数头部或上一次停下来的地方开始执行，知道遇到下一个yelid表达式（或return）语句为止.换言之，generator函数是分段执行的，yield表达式是暂停执行的标记，而next方法可以恢复执行

调用generator函数，返回一个遍历器对象，代表generator函数的内部指针。以后，每次调用遍历器对象的next方法,就会返回一个有着value和done两个属性的对象。value属性表示当前的内部状态的值，是yield表达式后面那个表达式的值;done属性是一个布尔值，表示是否遍历结束。

es6没有规定，function关键字和函数名之间的星号，写在哪个位置

任意一个对象的symbol.iterator方法，等于该对象的遍历器生成函数，调用该函数会返回该对象的一个遍历器对象

由于generator函数就是遍历器生成函数，因此可以把generator赋值给对象的symbol.iterator属性，从而使得该对象具有iterator接口

async就是generator函数的语法糖

async函数就是将genrator函数的星号变成async，将yield替换成await，仅此而已。

async函数对generator函数的改进，体现在以下四点

1.内置执行器

generator函数的执行必须依靠执行器，所以才有了co模块，而async函数自带执行器。也就是说async函数的执行于普通函数以，摸一样，只要一行

2.更好的语句

async和await，比星号和yield，语义更清楚了.async表示函数里有异步操作，await表示紧跟在后面的表达式需要等待结果

3.更广的适用性

co模块约定,yeild命令后面只能是thunk函数或promise对象，而async函数的await命令后面，可以是promise对象，而async函数的await命令的后面可以是promise对象和原始类型的值（数值，字符串和布尔值，但这时会自动转成立即resolved的promise对象）

4.返回值是promise

async函数的返回值是promise对象，这比generator函数的返回值是iterator对象方便。可以用then方法指定下一步的操作。进一步说，async函数完全可以看作多个异步操作，包装成的一个promise对象，而await命令就是内部then命令的1语法糖。

async函数返回一个promise对象，可以使用then方法添加回调函数，当函数执行的时候，一旦遇到await就会返回，等到异步操作完成，再接着执行函数体后面的语句。

async函数的语法规则总体上比较简单，难点是错误处理的机制

async函数返回一个promsie对象

async函数内部return语句返回的值，会成为then方法回调函数的参数

async函数内部抛出错误，会导致返回的promise对象变成reject状态，抛出的错误对象会被catch方法的回调函数接收到

promise对象的状态变化

async函数返回的promise对象，必须等到内部所有的await命令后面的promise对象执行完，才会发生状态改变。除非遇到return语句或者抛出错误。也就是说只有async函数内部的异步操作执行完，才会执行then方法指定的回调函数

await命令，正常情况下,await命令后面是一个promise对象，返回该对象的结果，如果不是promise对象，就直接返回对应的值。

如果await后面的异步操作出错，那么久等同于async函数返回的promise对象被reject。为了防止出错可以将代码块放在try...catch代码块之中去

class

类是对象的模板。通过class关键字，可以定义类

基本上,es6的class可以看作只是一个语法糖，它的绝大部分功能，es5都可以做到，新的class写法只是对象原型的写法更加清晰，更像面向对象编程的语法而已。

构造函数的prototype属性，在es6的类上面继续存在。事实上，类的所有方法都定义在类的prototype属性上

因此，在类的实例上面调用方法，其实就是调用原型上的方法

由于类的方法都定义在prototype对象上面，所以类的新方法可以添加在prototype对象上面。object.assign()方法可以很方便的一次向类添加多个方法

prototype对象的constructor（）属性，直接指向类的本身，这与es5的行为一致

类的内部定义的所有方法，都是不可枚举的

constructor（）方法是类的默认方法，通过new命令生成对象实例时，自动调用该方法。一个类必须有constructor（）方法，如果没有显示定义，一个空的constructor（）方法会被默认添加。

类的属性和方法，除非显示定义在其本身（即定义在this对象上),否则都是定义在原型上（即定义在class上）

es2022为类的实例属性，又规定了一种新的写法。实例属性现在处理可以定义在constructor（）方法里面的this上面，也可以定义在类内部的最顶层

取值函数（getter）和存值函数（setter)

与es5一样，早类的内部可以使用get和set关键字。对某个属性设置存值函数和取值函数，拦截存取的行为

类的属性名可以采用表达式

与函数一样 类也可以使用表达式的形式定义

类相当于实例的原型，所有在类中定义的方法，都会被实例继承，如果在一个方法前，加上static关键字，就表示该方法不会被实例继承，而是直接通过类来调用，这就称为静态方法

静态属性指的是Class本身的属性，即class.propname而不是定义在实例对象（this）上的属性

上面的写法为foo类定义了一个静态属性prop

目前只有这种写法可行，因为es6明确规定，class内部只有静态方法，没有静态属性，es2022更新了在属性前面加上static 静态属性

es2022正式为class添加了私有属性，方法是在属性名之前使用#号表示

class可以通过extends关键字实现继承，让子类继承父类的属性和方法。

es6规定，子类必须在constructor（）方法调用super（）否则就会报错，这是因为子类自己的this对象，必须先通过父类的构造函数完成塑造，得到同父类同样的实例属性和方法，然后再对其进行加工，添加子类自己的实例属性和方法。如果不调用super（）方法，子类就得不到自己的this对象

父类所有的属性和方法，都会被子类继承，除了私有属性和方法

子类无法继承父类的私有属性，或者说，私有属性只能在定义它的class里面使用

私有是前面加一个#

父类的静态属性和静态方法，也会被子类继承

object.getprototypeof()方法可以用来从子类上获取父类

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

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

第二种情况 super作为对象时，在普通方法中，指向父类的原型对象；在静态方法中，指向父类的原型对象；在静态方法中，指向父类

类的prototype属性和_proto_属性

大多数浏览器的es5实现之中，每一个对象都有_proto_属性，指向对应的构造函数的prototype属性。class作为构造函数的语法糖，同时有protype属性和_proto_属性，同时也存在两条继承链

子类的_proto_属性，表示构造函数的继承，总是指向父类

子类的prototype属性的_proto_属性，表示方法的继承，总是指向父类的prototype属性

原生构造函数的继承

原生构造函数是指语言内置的构造函数，通常用来生成数据结构

js模块语法

在es6之前，社区制定了一些模块加载的方案，最主要的有commmonJS和AMD两种

前者用于服务器，后者用于浏览器

es6模块的设计思想是尽量的静态画，使得编译时就能确定模块的依赖关系，以及输入和输出的变量.commonjs和amd模块，都只能在运行时确定这些东西。比如commonjs模块是对象，输入时必须查找对象属性

es6模块不是对象，而是通过export命令显示指定输出的代码在通过import命令输入

es6的模块自动采用严格模式，不管你有没有在模块头部加上use strict

模块功能主要由两个命令构成:export和import

export命令用于规定模块的对外接口，import命令用于输入其他模块提供的功能

一个模块就一个独立文件。该文件内部的所有变量，外部都无法获取。如果希望外部能够读取模块内部的某个变量，就必须使用export关键字输出该变量，下面是一个js文件，里面使用export命令输出变量

as关键字进行重命明，使用as关键给完不同的名字以后可以重复的进行输出

export命令规定的是对外的接口，必须与内部模块内部的变量建立一一对应关系

export语句输出的接口，与其对应的值都是动态绑定的关系，即通过接口，可以取到模块内部实时的值

使用export命令定义了模块的对外接口以后，其他的js文件就可以通关import命令加载这个模块

如果想为输入的变量重新取一个名字，import命令要使用as关键字，将输入的变量重命名

import后面的from指定模块文件的位置，可以是相对路径也可以是绝对路径。如果不带路径，只是一个模块名，那么必须有配置文件

import 命令具有提升效果，会提升大整个模块的头部，首先执行

import是静态执行，所以不能使用表达式和变量。

模块的整体加载 除了指定加载某个输出值，还可以使用整体加载，即用*号指定一个对象，所有的输出值都加在这个对象上面

使用import命令的时候，用户需要知道所加载的变量名和函数名，否则无法加载

export default 命令，为模块指定默认输出

其他模块加载该模块时，import命令可以为该匿名函数指定任意名字

如果在一个模块之中，先输入后输出同一个模块,import语句可以和export语句写在一起

模块的继承 模块之间也可以继承

es2020引入了import（）函数，支持动态加载模块

import（）函数返回一个promise对象

本身可以用在任何地方，不仅仅是模块，非模块的脚本也可以使用。它是运行时执行，也就是说，什么时候运行到这一句，就会加载指定的模块。另外,import（）函数所加载的模块没有静态连接关系。

<script></script>标签打开defer或async属性，脚本就会异步加载

defer和async的区别是：defer要等到整个页面在内存中正常渲染结束（dom结构完全生成，以及其他脚本执行完成）才会执行；async一旦下载完，渲染引擎就会终端渲染，执行这个脚本后，再继续渲染。defer是渲染完再执行，async是下载完就只想

浏览器加载es6模块，也使用script标签，但是要加入type='module'属性

编程风格

es6提出了两个新的声明变量的命名:let和const。其中,let完全可以取代var，因为两者语义相同且let没有副作用

在let和const之间，建议优先使用const，尤其是在全局环境，不应该设置变量，值应该设置常量

const优于let有几个原因.一个是const可以提醒阅读程序的人，这个变量是不可变更的。另一个是const比较符合函数式编程思想，运算不改变值，只是新建值，而且这样也有利于将来的分布式运算；js编译器会对const进行优化,所以多使用const有利于提高程序的运行效率

字符串

静态字符串一律使用单引号或反引号，不使用双引号。动态字符串使用反引号

结构赋值

使用数组成员对变量赋值时，优先使用解构赋值

函数参数如果是对象的成员，优先使用解构赋值

如果函数返回多个值，优先使用对象的结构赋值，而不是数组的结构赋值，这样便于以后添加返回值，以及更改返回值的顺序

对象

单号定义的对象，最后一个成员不以逗号结尾。多行定义的对象，最后一个成员以逗号结尾

对象尽量静态化，一旦定义，就不得随意添加新的属性，如果添加新属性不可避免，要是有object.assign方法

数组

使用扩展元运算符(...)拷贝数组

使用array.form方法，将类似数组的对象转换为数组

函数

立即执行的函数可以写出箭头函数的形式

那些使用匿名函数的场合，尽量使用箭头函数替代

map结构

注意区分object和map，只有模拟线上世界的实体对象时，才使用object。如果只需要key:value的数据结构，使用map结构。因为map有内建的遍历机制

class

总是用class，取代需要prototype的操作。因为class的写法更简洁，更易于理解

使用extend实现继承，因为这样更简单不会有破坏instanceof运算的危险

模块

es6模块语法是js模块的标准语法，坚持使用这种写法

抽象操作就是引擎的一些内部方法，外部不能调用。规格定义了一系列的抽象操作，规定了它们的行为