Promise理解

ES6 Generator/Promise

Generator

node -harmony app.js (harmony 告訴Node使用ES6來運行)

yield（不能再普通函數中，只能在function* 這樣的Generator函數中，擁有next方法）

next 方法的參數表示上一個 yield 語句的返回值，因此第一次使用 next 方法時，不能帶有參數。V8 引擎直接忽略第一次使用 next 方法時的參數，只有從第二次使用 next 方法開始，參數纔是有效的。

function* ticketGenerator() {
   yield 1;
    yield 2;
    yield 3;
    //yield,return有些像，都能返回緊跟語句後面的表達式的值，
    //區別是每次遇到yield,函數是暫停執行，下一次再從該位置繼續向後執行
    //而return不具有位置記憶功能，只能執行一次，因此一個函數只能返回一個值
    return 4; //yield 4; {value: 4, done: false}
}

const takeANumber = ticketGenerator();

var i = 0;
while (i < 4) {
    i++;
    console.log(takeANumber.next())
}
// { value: 1, done: false }
// { value: 2, done: false }
// { value: 3, done: false }
// { value: 4, done: true }

//for ... of依次顯示yield的值，一旦next方法返回的對象的done爲
//true, 循環就會終止
for (var v of ticketGenerator()) {
    console.log(v);
}

進階：

function* foo(x) {
  var y = 2 * (yield (x + 1));
  var z = yield (y / 3);
  return (x + y + z);
}

var it = foo(5);

it.next()
// { value:6, done:false }
it.next(12)
// { value:8, done:false }
it.next(13)
// { value:42, done:true }

若是 yield 命令後面跟的是一個遍歷器，須要在 yield 命令後面加上星號，代表它返回的是一個遍歷器。這被稱爲 yield語句。*

Promise(解決異步操做的對象)

• pending - The initial state of a promise.
• fulfilled - The state of a promise representing a successful operation.
• rejected - The state of a promise representing a failed operation.

Promise庫

• bluebird
• Q
• then.js
• es6-promise
• ypromise
• async
• native-promise-only

API:

new Promise((resolve, reject) => {})

Static Methods:

Promise.resolve(value) --返回一個使用接收到的值進行了resolve的新的promise對象
Promise.reject(value) --返回一個使用接收到的值進行了reject的新的promise對象
Promise.all(array)
生成並返回一個新的promise對象。
當這個數組裏的全部promise對象所有變爲resolve或reject狀態的時候，它纔會去調用 .then 方法。

eg: 
Promise.all([Promise.resolve('a'), 'b', Promise.resolve('c')])
.then(function (res) {
  assert(res[0] === 'a')
  assert(res[1] === 'b')
  assert(res[2] === 'c')
})

Promise.race(array)
生成並返回一個新的promise對象。
參數 promise 數組中的任何一個promise對象若是變爲resolve或者reject的話， 該函數就會返回，並使用這個promise對象的值進行resolve或者reject。
eg:
var p1 = Promise.resolve(1),
    p2 = Promise.resolve(2),
    p3 = Promise.resolve(3);
Promise.race([p1, p2, p3]).then(function (value) {
    console.log(value);  // 1
});

Prototype Methods:

Promise.then(onFulfilled, onRejected)
Promise.catch(onRejected)

Example:

function taskA() {
    console.log("Task A");
    throw new Error("throw Error Task A")
}
function taskB() {
    console.log("Task B");
}
function onRejected(error) {
    console.log("Catch Error: ", error);
}
function finalTask() {
    console.log("Final Task");
    throw new Error("throw Error Final task")
}

var promiseB = new Promise((resolve, reject) => reject(new Error('error msg')))
promiseB
.then(success => console.log('onfulfilled ', success), err => console.log('onRejected ', err))
.then(taskA)
.then(taskB)
.catch(onRejected)
.then(finalTask);

//output: 
//onRejected Error: error msg
//Task A 
//Catch Error: Error: throw Error Task A ---並無執行task B
//Final Task

promiseB 進入onRejected callback後，依舊會執行Task A, 並不會被 onRejected catch住。
taskA 發生error，不會執行taskB，會直接到 onRejected -> finalTask

promise chain中，因爲在 onRejected 和 finalTask 後面沒有 catch 處理了，所以在這兩個Task中若是出現異常的話將不會被捕獲,只會出現如下warning：

• (node:83039) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 2): Error: throw Error Final task
• (node:83039) DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.