ES6学习——Promises：API介绍

Promise的API并不是很多，下面一个一个简单看一下：

1）构造函数Promise ( executor )

let promise = new Promise(
    function (resolve, reject) {
        if (...) {
            resolve(value); // success
        } else {
            reject(reason); // failure
    }
});

规范中关于构造函数有这样两条：

1. If NewTarget is undefined, throw a TypeError exception.
2. If IsCallable(executor) is false, throw a TypeError exception.

可以解释为：Promise只能用new创建对象，不能当函数调用；参数executor必须是个函数

2）Promise.all ( iterable )

The all function returns a new promise which is fulfilled with an array of fulfillment values for the passed promises, or rejects with the reason of the first passed promise that rejects. It resolves all elements of the passed iterable to promises as it runs this algorithm.

大概意思就是根据传入的promises创建一个新的promise，当所有promises状态都变成fulfilled或者任意一个promise状态变成rejected，新创建的promise状态就会跟着确定。

var p1 = new Promise( function pr(resolve){
	setTimeout( function(){
		resolve( 41 );
	},50);
});
var p2 = new Promise( function pr(resolve){
	setTimeout( function(){
		resolve( 43 );
	},100);
});

var p3 = new Promise( function pr(resolve,reject){
	setTimeout( function(){
		reject( "Oops" );
	},10);
});

Promise.all([p1,p2]).then(function(results){
	console.log(results);//[41,43]
})

Promise.all([p3,p2]).then(function(results){
	console.log(results);//这里不会执行
}).catch(function(reason){
	console.log(reason);//Oops
})

上面的then和catch方法下面会有介绍。这里还需要注意个问题，就是all方法会新创建一个Promise，这个新创建的Promise遵循Symbol.species模式，可以创建自定义的Promise类型：

class MyPromise extends Promise{
	constructor(executor){
		super(executor);
	}
}

Object.defineProperty(//仔细看这里，注意和Array的区别，请参考4.6那篇文章
	Promise, Symbol.species, {
		value: MyPromise
});

var p1 = Promise.resolve(21);
var p2 = Promise.resolve(212);

var pAll = Promise.all([p1,p2]);
trace(pAll instanceof Promise);//true
trace(pAll instanceof MyPromise);//true

上面这段代码在Kinoma Studio中测试通过，这种模式在浏览器中还不支持。Promise中的API在新创建Promise的时候都采用上面的这种模式。

3）Promise.race ( iterable )

这个API和all模式正好相反，只要有任意一个promise状态为fulfilled或者rejected，新创建的promise状态就会跟着确定。

这里还有一个问题需要注意，仔细看区别：

Promise.all([]).then(function(){
	console.log("all OK!");//立即执行
})

Promise.race([]).then(function(){
	console.log("race OK!");//永远不会执行！
})

4）Promise.reject ( r )

创建一个状态为rejected的promise

var p1 = Promise.reject( "Oops" );

var p2 = new Promise( function pr(resolve,reject){
    reject( "Oops" );
} );

上面的p1和p2意义是相同的。

5）Promise.resolve ( x )

如果x类型是Promise，则直接返回x；

如果x是thenable的，则把x转换成一个Promise，并返回。

如果x是其他类型的，则新创建一个状态为fulfilled的Promise，把结果设置成x，并返回。

var p = new Promise(function(resolve,reject){
	setTimeout(function(){
		resolve(1);
	},2000);
});

var p1 = Promise.resolve(p);
p === p1//true

var thenable = {
	then:function(resolve,reject){
		resolve(40);
	}
}

Promise.resolve(thenable).then(function(result){
	console.log(result);//40
});

var p1 = Promise.resolve( 42 );
p1.then(function(result){
    console.log(result)//42
})

6）Promise.prototype.then ( onFulfilled , onRejected )

当Promise状态确定时，执行。不想在啰嗦了，用过的都知道

7）Promise.prototype.catch ( onRejected )

当Promise状态确定为rejected时，或者在executor中抛出异常时，执行。

new Promise(function (resolve, reject) {
    throw new Error();
    //reject("error");
})
.catch(function (err) {
    // Handle error here
});

最后简单说一下thenable——

概念很简单，就是如果一个对象里面定义了then方法，Promise有些API会把这个对象转换成标准的Promise对象，规范的25.4.4.2中详细描述了转换的过程。看几个例子，理解一下转换的过程：

var thenable1 = {
	then:function(resolve,reject){
		resolve(40);
	}
}

var thenable2 = {
	then:function(resolve,reject){
		reject("error");
	}
}

var thenable3 = {
	then:function(resolve,reject){
		resolve(10);
		reject("error");//忽略
	}
}

Promise.resolve(thenable1).then(function(result){
	console.log(result);//40
});

Promise.resolve(thenable2).then(function(result){
	console.log(result);
},function(reason){
	console.log(reason);//error
});

Promise.resolve(thenable3).then(function(result){//通过转换，标准化Promise。因为Promise一旦状态被确定成fulfilled了，就不能在变。所以reject调用失效
	console.log(result);//10
});

Promise.resolve(thenable1).then(function(result1){
	console.log(result1);
	return thenable2;//返回thenable对象
}).catch(function(reason){
	console.log(reason);
	return thenable3;//返回thenable对象
}).then(function(result3){
	console.log(result3);
});

*以上代码，除了特殊说明的以外，都在Chrome 47下通过测试