異步編程

程序執(zhí)行分為同步和異步，如果程序每執(zhí)行一步都需要等待上一步完成才能開始，此所謂同步。如果程序在執(zhí)行一段代碼的同時可以去執(zhí)行另一段代碼，等到這段代碼執(zhí)行完畢再吧結(jié)果交給另一段代碼，此所謂異步。
比如我們需要請求一個網(wǎng)絡(luò)資源，由于網(wǎng)速比較慢，同步編程就意味著用戶必須等待下載處理結(jié)束才能繼續(xù)操作，所以用戶體驗極為不好；如果采用異步，下載進(jìn)行中用戶繼續(xù)操作，當(dāng)下載結(jié)束了，告訴用戶下載的數(shù)據(jù)，這樣體檢就提升了很多。因此異步編程十分重要。
從計算機(jī)的角度來講，js 只有一個線程，如果沒有異步編程那一定會卡死的！異步編程主要包括以下幾種：

• 回調(diào)函數(shù)
• 事件監(jiān)聽
• 發(fā)布/訂閱模型
• Promise對象
• ES6異步編程

回調(diào)函數(shù) 和 Promise

回調(diào)函數(shù)應(yīng)該是 js 中十分基礎(chǔ)和簡單的部分，我們在定義事件，在計時器等等使用過程中都使用過：

fs.readFile('/etc/passwd', function(err, data){
  if(err) throw err;
  console.log(data);
});

比如這里的這個文件讀取，定義了一個回調(diào)函數(shù)，在讀取文件成功或失敗是調(diào)用，并不會立刻調(diào)用。

如同之前在 Promise 中提到的，當(dāng)我想不斷的讀入多個文件，就會遇到回調(diào)函數(shù)嵌套，書寫代碼及其的不方便，我們稱之為"回調(diào)地獄"。因此 ES6 中引入是了 Promise 解決這個問題。具體表現(xiàn)參看之前的 Promise 部分。但是 Promise 也帶來了新的問題，就是代碼冗余很嚴(yán)重，一大堆的 then 使得回調(diào)的語義不明確。

協(xié)程

所謂協(xié)程就是幾個程序交替執(zhí)行：A開始執(zhí)行，執(zhí)行一段時間后 B 執(zhí)行，執(zhí)行一段時間后再 A 繼續(xù)執(zhí)行，如此反復(fù)。

function* asyncJob(){
  //...
  var f = yield readFile(fileA);
  //...
}

通過一個 Generator 函數(shù)的 yield， 可以將一個協(xié)程中斷，去執(zhí)行另一個協(xié)程。我們可以換一個角度理解 Generator 函數(shù)：它是協(xié)程在 ES6 中的具體體現(xiàn)。我們可以簡單寫一個異步任務(wù)的封裝：

var fetch = require('node-fetch');
function* gen(){
  var url = 'http://api.github.com/users/github';
  var result = yield fetch(url);
  console.log(result.bio);
}

var g = gen();
var result = g.next();    //返回的 value 是一個 Promise 對象
result.value.then(function(data){
  return data.json;
}).then(function(data){
  g.next(data);
});

Thunk 函數(shù)

在函數(shù)傳參數(shù)時我們考慮這樣一個問題：

function fun(x){
  return x + 5;
}
var a = 10;
fun(a + 10);

這個函數(shù)返回25肯定沒錯，但是，我們傳給函數(shù) fun 的參數(shù)在編譯時到底保留 a + 10 還是直接傳入 20？顯然前者沒有事先計算，如果函數(shù)內(nèi)多次使用這個參數(shù)，就會產(chǎn)生多次計算，影響性能；而后者事先計算了，但如果函數(shù)里不使用這個變量就白浪費(fèi)了性能。采用把參數(shù)原封不動的放入一個函數(shù)(我們將這個函數(shù)稱為 Thunk 函數(shù))，用的使用調(diào)用該函數(shù)的方式。也就是上面的前一種方式傳值。所以上面代碼等價于：

function fun(x){
  return x() + 5;
}
var a = 10;
var thunk = function(){ return a + 10};
fun(thunk);

但是 js 不是這樣的！js 會把多參數(shù)函數(shù)給 Thunk 了，以減少參數(shù)：

var fs = require('fs');
fs.readFile(fileName, callback);
var readFileThunk = Thunk(fileName);
readFileThunk(callback);

var Thunk = function(fileName){
  return function(callback){
    return fs.readFile(fileName,callback);
  };
};

這里任何具有回調(diào)函數(shù)的函數(shù)都可以寫成這樣的 Thunk 函數(shù)，方法如下：

function Thunk(fn){
  return function(){
    var args = Array.prototype.slice.call(arguments);
    return function (callback){
      args.push(callback);
      return fn.apply(this, args);
    }
  }
}

//這樣fs.readFile(fileName, callback); 寫作如下形式

Thunk(fs.readFile)(fileName)(callback);

關(guān)于 Thunk 函數(shù), 可以直接使用 thunkify 模塊：

npm install thunkify

使用格式和上面的Thunk(fs.readFile)(fileName)(callback);一致，但使用過程中需要注意，其內(nèi)部加入了檢查機(jī)制，只允許 callback 被回調(diào)一次！

結(jié)合 Thunk 函數(shù)和協(xié)程，我們可以實現(xiàn)自動流程管理。之前我們使用 Generator 時候使用 yield 關(guān)鍵字將 cpu 資源釋放，執(zhí)行移出 Generator 函數(shù)?？梢栽趺匆苹貋砟?？之前我們手動調(diào)用 Generator 返回的迭代器的 next() 方法，可這畢竟是手動的，現(xiàn)在我們就利用 Thunk 函數(shù)實現(xiàn)一個自動的：

var fs = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile);

var gen = function*(...args){    //args 是文件路徑數(shù)組
  for(var i = 0, len = args.length; i < len; i++){
    var r = yield readFile(args[i]);
    console.log(r.toString());
  }
};

(function run(fn){
  var gen = fn();
  function next(err, data){
    if(err) throw err;
    var result =  gen.next(data);
    if(result.done) return;    //遞歸直到所以文件讀取完成
    result.value(next);    //遞歸執(zhí)行
  }
  next();
})(gen);

//之后可以使用 run 函數(shù)繼續(xù)讀取其他文件操作

如果說 Thunk 可以有現(xiàn)成的庫使用，那么這個自動執(zhí)行的 Generator 函數(shù)也有現(xiàn)成的庫可以使用——co模塊(https://github.com/tj/co)。用法與上面類似，不過 co 模塊返回一個 Promise 對象。使用方式如下：

var co = require('co');
var fs = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile);

var gen = function*(...args){    //args 是文件路徑數(shù)組
  for(var i = 0, len = args.length; i < len; i++){
    var r = yield readFile(args[i]);
    console.log(r.toString());
  }
};
co(gen).then(function(){
  console.log("files loaded");
}).catch(function(err){
  console.log("load fail");
});

這里需要注意的是：yield 后面只能跟一個 thunk 函數(shù)或 promise 對象。上例中第8行 yield 后面的 readFile 是一個 thunk 函數(shù)，所以可以使用。
上面已經(jīng)講解了 thunk 函數(shù)實現(xiàn)自動流程管理，下面使用 Promise 實現(xiàn)一下：

var fs = require('fs');
var readFile = function(fileName){
  return new Promise(function(resolve, reject){
    fs.readFile(fileName, function(error,data){
      if(error) reject(error);
      resolve(data);
    });
  });
};

var gen = function*(){
  for(var i = 0, len = args.length; i < len; i++){
    var r = yield readFile(args[i]);
    console.log(r.toString());
  }
};

(function run(gen){
  var g = gen();

  var resolve = function(data){
    var result = g.next(data);
    if(result.done) return result.value;
    result.value.then(resolve);
  }
  g.next().value.then(function(data){
    resolve(data);
  });
  resolve();
})(gen);
//之后可以使用 run 函數(shù)繼續(xù)讀取其他文件操作

async 函數(shù)

ES7 中提出了 async 函數(shù)，但是現(xiàn)在已經(jīng)可以用了！可這個又是什么呢？其實就是 Generator 函數(shù)的改進(jìn),我們上文寫過一個這樣的 Generator 函數(shù)：

var gen = function*(){
  for(var i = 0, len = args.length; i < len; i++){
    var r = yield readFile(args[i]);
    console.log(r.toString());
  }
};

我們把它改寫成 async 函數(shù)：

var asyncReadFiles = async function(){    //* 替換為 async
  for(var i = 0, len = args.length; i < len; i++){
    var r = await readFile(args[i]);   //yield 替換為 await
    console.log(r.toString());
  }
};

async 函數(shù)對 Generator 函數(shù)做了一下改進(jìn)：

• Generator 函數(shù)需要手動通過返回值的 next 方法執(zhí)行，而 async 函數(shù)自帶執(zhí)行器，執(zhí)行方式和普通函數(shù)完全一樣。

var result = asyncReadFiles(fileA, fileB, fileC);

• 語義明確，async 表示異步，await 表示后續(xù)表達(dá)式需要等待觸發(fā)的異步操作結(jié)束
• co 模塊中 yield 后面只能跟一個 thunk 函數(shù)或 promise 對象，而 await 后面可以是任何類型(不是 Promise 對象就同步執(zhí)行)
• 返回值是一個 Promise 對象，不是 Iterator ，比 Generator 方便

我們可以實現(xiàn)這樣的一個 async 函數(shù):

async function asyncFun(){
  //code here
}
//equal to...
function asyncFun(args){
  return fun(function*(){
    //code here...
  });
  function fun(genF){
    return new Promise(function(resolve, reject){
      var gen = genF();
      function step(nextF){
        try{
          var next = nextF();
        } catch(e) {
          return reject(e);
        }
        if(next.done){
          return resolve(next.value);
        }
        Promise.resolve(next.value).then(function(data){
          step(function(){ return gen.next(data); });
        }, function(e){
          step(function(){ return gen.throw(e); });
        });
      }
      step(function() { return gen.next(undefined); });
    });
  }
}

我們使用 async 函數(shù)做點(diǎn)簡單的事情：

function timeout(ms){
  return new Promise((resolve) => {
    setTimeout(resolve, ms);
  });
}

async function delay(nap, ...values){
  while(1){
    try{
      await timeout(nap);
    } catch(e) {
      console.log(e);
    }
    var val = values.shift();
    if(val)
      console.log(val)
    else
      break;
  }
}
delay(600,1,2,3,4);   //每隔 600ms 輸出一個數(shù)

這里需要注意：應(yīng)該把后面跟 promise對象的 await 放在一個 try 中，防止其被 rejected。當(dāng)然上面的 try 語句也可以這樣寫：

var ms = await timeout(nap).catch((e) => console.log(e));

對于函數(shù)參數(shù)中的回調(diào)函數(shù)不建議使用，避免出現(xiàn)不應(yīng)該的錯誤

//反例: 會得到錯誤結(jié)果
async function fun(db){
  let docs = [{},{},{}];

  docs.forEach(async function(doc){   //ReferenceError: Invalid left-hand side in assignment
    await db.post(doc);
  });
}

//改寫, 但依然順序執(zhí)行
async function fun(db){
  let docs = [{},{},{}];

  for(let doc of docs){
    await db.post(doc);
  }
}

//改寫, 并發(fā)執(zhí)行
async function fun(db){
  let docs = [{},{},{}];
  let promises = docs.map((doc) => db.post(doc));
  let result = await Promise.all(promises)
  console.log(result);
}

//改寫, 并發(fā)執(zhí)行
async function fun(db){
  let docs = [{},{},{}];
  let promises = docs.map((doc) => db.post(doc));
  let result = [];
  for(let promise of promises){
    result.push(await promise);
  }
  console.log(result);
}

Promise，Generator 和 async 函數(shù)比較

這里我們實現(xiàn)一個簡單的功能，可以直觀的比較一下。實現(xiàn)如下功能：

在一個 DOM 元素上綁定一系列動畫，每一個動畫完成才開始下一個，如果某個動畫執(zhí)行失敗，返回最后一個執(zhí)行成功的動畫的返回值

• Promise 方法

function chainAnimationPromise(ele, animations){
  var ret = null;  //存放上一個動畫的返回值
  var p = Promise.resolve();
  for(let anim of animations){
    p = p.then(function(val){
      ret = val;
      return anim(ele);
    });
  }
  return p.catch(function(e){
    /*忽略錯誤*/
  }).then(function(){
    return ret;  //返回最后一個執(zhí)行成功的動畫的返回值
  });
}

• Generator 方法

function chainAnimationGenerator(ele, animations){
  return fun(function*(){
    var ret = null;
    try{
      for(let anim of animations){
        ret = yield anim(ele);
      }
    } catch(e) {
      /*忽略錯誤*/
    }
    return ret;
  });

  function fun(genF){
    return new Promise(function(resolve, reject){
      var gen = genF();
      function step(nextF){
        try{
          var next = nextF();
        } catch(e) {
          return reject(e);
        }
        if(next.done){
          return resolve(next.value);
        }
        Promise.resolve(next.value).then(function(data){
          step(function(){ return gen.next(data); });
        }, function(e){
          step(function(){ return gen.throw(e); });
        });
      }
      step(function() { return gen.next(undefined); });
    });
  }
}

• async 函數(shù)方法

async function chainAnimationAsync(ele, animations){
  var ret = null;
  try{
    for(let anim of animations){
      ret = await anim(elem);
    }
  } catch(e){
    /*忽略錯誤*/
  }
  return ret;
}

一個經(jīng)典題

console.log(0);

setTimeout(function(){
  console.log(1)
},0);
setTimeout(function(){
  console.log(2);
},1000);

var pro = new Promise(function(resolve, reject){
  console.log(3);
  resolve();
}).then(resolve => console.log(4));

console.log(5);

setTimeout(function(){
  console.log(6)
},0);

pro.then(resolve => console.log(7));

var pro2 = new Promise(function(resolve, reject){
  console.log(8);
  resolve(10);
}).then(resolve => console.log(11))
  .then(resolve => console.log(12))
  .then(resolve => console.log(13));

console.log(14);

// 0 3 5 8 14 4 11 7 12 13 1 6 2