ES6:

symbol（对象属性符）

1. symbol基本数据类型
2. symbol要用[]访问，不然只是普通String

var msb=symbol();var a={};a.msb='hello'; //.操作符后面跟String类型属性a.msb //undefineda['msb'] //'hello'复制代码

3. symbol属性不可枚举，但也不是私有变量，只能用Object.getOwnPropetySymbols方法返回当前用作属性名的symbol的数组
4. api:

symbol.for('prop') //如果prop为名称的symbol未定义，就创建一个新的，否则指向同一个(在全局环境中登记)  symbol('prop') //每次返回一个新的symbol变量（未登记所以)  symbol.keyFor('') //返回一个symbol变量有登记的key复制代码

=>(箭头函数)

1. 本身无this,所以this引用外层的this。（依赖this的方法无效。所以不能用于构造函数
2. 多条语句最外层要用{}括起，{}默认不返回值，所以要标明{return /*..*/}
3. 因为{}会被当成代码块，所以箭头函数返回对象要加括号。

var a=(b,c)=>b>c;var a= b => ({
   b:b});var a=(b)=>{
   let c;return b>c}复制代码

module(模块)

CommonJS

module

  模块可以多次加载，但是只会在第一次加载时运行一次，然后运行结果就被缓存了，以后再加载，就直接读取缓存结果。要想让模块再次运行，必须清除缓存。

module.id  //模块的识别符，通常是带有绝对路径的模块文件名。    module.filename //模块的文件名，带有绝对路径。  module.loaded //返回一个布尔值，表示模块是否已经完成加载   module.exports //模块对外输出接口，加载模块实质为读取module.loaded变量复制代码

exports

exports为对象,直接添加属性

exports.try=function try(){/*..*/}; 如果exports要输出函数module.exports=function try(){/*..*/}

require

var try=require('./try');

  require命令的基本功能是，读入并执行一个JavaScript文件，然后返回该模块的exports对象。如果exports的是函数，则可以直接执行。

ES6 module

数据是引用的，当某一模块变动，输入模块也随之变动。

浏览器引入模块

复制代码

export

1. 普通输出

可输出变量、函数和类

export var a;export function a(){...};export class a{...};复制代码

或

var a=function(){...},b=function(){...};export {a,b};复制代码

2. 将a命名为what1输出

export {a as what1,b as what2}

3. 默认输出

export default function(){...}; //本质输出一个default变量

4. 注意

错误

export 1; //要输出接口，不是值var a=1;export a; //同上复制代码

正确

export var a=1;var a=1;export {a};复制代码

import

import的变量会提升到顶部

import {a} from "./"  //普通引入import *as a from "./"  //整体加载import whatEver from"./"  //默认加载，可用任意名引入复制代码

动态import,返回Promise对象

import(url);复制代码

异步

并发

  两个或多个事件在极小时间间隔下交替执行，就像在同时进行。

latch

  高并发状态下，利用if(!latch) latch=true;使请求只能提交一次

Promise

Promise与事件回调区别： Promise侦听通知并调用回调函数。

事件回调发出通知并调用回调函数。

new Promise

var doSomething=new Promise(function(resolve,reject){  //done  if(/*成功的条件*/) resolve(value);//执行下面then定义的resolve函数  else reject(error);//执行下面then定义的reject函数});复制代码

Promise.prototype.then()

  创建对象后，用promise对象的then方法定义fulfilled和rejected函数。then方法return一个新的Promise实例。

doSomething.then(function(value){    //content of fulfilled   }，function(error){      //content of rejected  });复制代码

then不会阻塞任务队列

var doSomething=new Promise(function(resolve){  resolve();});doSomething.then(function(){  console.log('A');  doSomething.then(function(){    console.log('B');  });});doSomething.then(function(){  console.log('C');});A C B复制代码

Promise.prototype.catch()

doSomething.then(/*...*/).catch(function(err){  //捕获catch前所有链式操作出现的错误  console.log(err);}).then(/*...*/); //如catch没错误，则会直接执行下一个then复制代码

*推荐使用catch方法代替then的第二个参数

Promise.all([...])

多个Promise实例包装为一个实例。//逻辑'与'

(1)只有所有实例都变成fulfilled，包装实例才为fulfilled。 (2)只要一个rejected，则为rejected，第一个被reject的返回值传给包装Promise实例的Callback

Promise.race([...])

  多个Promise实例包装为一个实例。 只要一个实例发生改变，包装实例的状态就随之改变，先改变的实例的返回值传给包装实例的Callback

Promise.resolve()

1. 传递非Promise对象，且非thenable的值:

var p1=new Promise(function(resolve,reject){  resolve(a););var p2=Promise.resolve(a);复制代码

p1、p2行为相同，相当于创建一个新的Promise对象并把参数传给resolve函数

2. 传递Promise对象：

var p1=Promise.resolve(a);var p2=Promise.resolve(p1);p1===p2 //true复制代码

返回同一个Promise。

3. 传递非Promise，但thenable的值 会展开该值，并持续到提取出一个具体的非类Promise的最终值。

Iteratiion

Iterator（迭代器）

  当一个对象被认为是一个迭代器时，它实现了一个 next()的方法。

next() 返回一个对象的无参函数，被返回对象拥有两个属性:

---

done (boolean)-如果迭代器已经经过了被迭代序列时为 true。这时 value 可能描述了该迭代器的返回值。 如果迭代器可以产生序列中的下一个值，则为 false。这等效于连同 done 属性也不指定。

value -迭代器返回的任何 JavaScript 值。done 为 true 时可省略。

function makeIterator(array){    var nextIndex = 0;        return {       next: function(){           return nextIndex < array.length ?               {
   value: array[nextIndex++], done: false} :               {
   done: true};       }    };}var it = makeIterator(['yo', 'ya']);console.log(it.next().value); // 'yo'console.log(it.next().value); // 'ya'console.log(it.next().done);  // true复制代码

Iterable（可迭代对象）

  为了变成可迭代对象， 一个对象必须实现 @@iterator方法, 意思是这个对象（或者它原型链prototype chain 上的某个对象）必须有一个名字是 Symbol.iterator的属性

一些接收Iterable为参数的API：for-of 循环，spread operator展开语法（[.../* */]）, yield* 和 destructuring assignment（解构赋值）。

var myIterable = {};myIterable[Symbol.iterator] = function* () {    yield 1;    yield 2;    yield 3;};[...myIterable]; // [1, 2, 3]复制代码

Generator

  Generator属于Iterator生成函数，执行后返回一个Iterator对象,是该函数的实例。该对象的[Symbol.iterator]方法执行后返回该对象本身。

function* gen(){  var y= yield x*2}var g=gen(); //返回值是一个Iterator对象。g[Symbol.iterator]()===g; //truea.next();  // {value: 4, done: false}a.next(); //继续执行 {value: 4, done: true}复制代码

yield

  函数运行到此便会暂停，默认返回undefined。

Generator.prototype.next()

  跳转到下一个yield。参数代表上一个yield的返回值。next()返回值是一个对象，包含2个属性done和value。（见Iteratation）

1. 有return 返回
2. 无reruen 返回

Generator.prototype.throw()

函数会抛出错误

Generator.prototype.return()

  返回参数值并终结生成器，如无参数则返回undefined。如果有try...catch语句则等待执行完成再返回。

yield*

  在Generator函数中调用别的Generator函数。

function* foo(){   yield 'a';   yield 'b';  }  function* bar(){   yield 'c';   yield* foo();   yield 'd';}       ↑ function* bar(){  yield 'c';    for(val of foo()){   yield val;}   yield 'd';}复制代码

async

  async返回一个Promise对象。await等待并处理Promise的结果，如果不是Promise对象，则会返回值本身，然后执行函数体后面的语句。

async function fn(){  var y= await 2;   return y;}fn.then(function(val){    console.log(val); //2});复制代码

  async返回值传给Promise.resolve()处理。

  如果await语句触发reject则函数返回的Promise对象状态变为rejected，后续语句将不会执行。所以最好将await语句放在try...catch语句中