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.