继续填坑
模式
考虑下面的代码：
function fn(x) {
//do something
return new Promise(function(resolve, reject) {
//调用resolve(..)和reject(...)
});
}
var p = fn(2);
new Promise(..)模式通常称为revealing constructor。传入函数会立即执行(不会像then(..)中的回调一样异步延迟)，它有两个参数，分别为resolve和reject。这些是promise的决议函数。resolve通常标识完成，reject标识拒绝。
鸭子类型
如何判断一个对象是不是一个Promise？虽然promise是通过new Promise(..)创建的，但是无法通过instanceof Promise来检测，最主要的原因是promise可能来自其他的窗口，检查无法识别这样的Promise实例。
识别Promise的方法被定义为是否具有then方法。也就是说，任何对象和函数，如果有then(包括原型链上)方法，就认为是一个Promise对象。
逻辑大概如下：
if (
p !== null &&
(typeof p === 'object' || typeof p === 'function') &&
typeof p.then === 'function'
) {
//这是一个promise对象
}
Promise特点
1、对一个Promise调用then时，提供的回调永远会被异步调用。
2、只要promise被决议，提供给then的回调会被自动调用，永远返回一个值。
promise与竞态
虽然说一旦promise被决议，后续then方法的回调一定会被调用，但是决议本身未被执行，只能通过别的机制来强制执行：
//必须返回一个promise
function delay(time) {
return new Promise(function(resolve, reject) {
setTimeout(function() {
reject('time out');
}, time);
});
}
//3秒内未决议就会被reject
Promise.race(p, delay(3000)).then(function() {
//success
}, function(err) {
//failed
})
Promise异常
考虑下面的代码：
var p = new Promise(function(resolve, reject) {
//异常
fo();
})
p.then(function(data) {
console.log(data);
}, function() {
//这个reject接受了异常 并又搞出了一个异常
foo();
}).then(function() {
}, function() {
//这个reject处理了最后的异常
console.log(1);
});
可以看出，每一个then方法会返回一个promise，并且一旦决议就不会改变，异常会转接到下一个then的reject。
Promise的回调
看起来promise也是利用回调函数完成异步操作，但是有一些不同。
关于Promise.resolve(..)
如果向Promise.resolve(..)传递一个非Promise、非thenable(即有then方法的对象或函数)的立即值，就会得到一个用这个值填空的promise，相当于包装。
下面两种情况，p1和p2的行为是一样的：
var p1 = new Promise(function(resolve, reject) {
resolve(42);
});
var p2 = Promise.resolve(42);
console.log(p2); //Promise {[[PromiseStatus]]: "resolved", [[PromiseValue]]: 42}
而如果向Promise.resolve(..)传递一个真正的Promise，就只会返回同一个promise。
var p1 = Promise.resolve(42);
var p2 = Promise.resolve(p1);
console.log(p1 === p2); //true
如果向Promise.resolve(..)传递了一个非Promise的thenable值，前者会试图展开这个值，而且展开过程会持续到提取出一个具体的非类Promise的最终值。
比如说：
var p = {
then: function(resolve, reject) {
resolve(42);
// reject('123');
}
};
p.then(function resolve(val) {
console.log(val);
}, function reject(err) {
console.log(err);
});
Promise.resolve(p); //打印42 得到一个Promise
Promise.resolve(..)可以接受任何thenable，将其解封为非thenable的值。从Promise.resolve(..)得到的肯定是一个Promise，是一个可信任的值。
将一个未知工具封装Promise并解析，可以这样：
Promise.resolve('tool').then(function(val) {
console.log(val);
});
这样，可以将所有未知封装为Promise，保证异步调用。
链式调用
可以把多个Promise连接到一起以表示一系列异步步骤：
1、每次调用then(..)，它都会创建并返回一个新的Promise，我们可以将其链接起来。
2、不管从then(..)调用的完成回调返回的值是什么，都会被设置为被链接Promise。
不太懂啊：
var p = Promise.resolve(2);
var p2 = p.then(function(v) {
console.log(v); //
return v * 2;
});
p2.then(function(v) {
console.log(v); //
});
通过Promise.resolve对2进行封装，调用第一个then方法得到数据2。接着返回一个包含4的Promise封装对象，由调用then方法获取到4。
只要通过return和then方法，就能实现Promise链式调用。
Ajax案例
链式调用可以与ajax完美结合，如下例：
//假设存在方法ajax(url,callback)
function request(url) {
return new Promise(function(resolve, reject) {
//ajax的回调函数是promise的resolve()函数
ajax(url, resolve);
});
}
//异步请求返回数据data
request('http://...').then(function(data) {
//将返回的数据拼接到第二个url作为参数再次请求
return request('http://...?data=' + data);
}).then(function(data2) {
//得到最终数据
console.log(data2);
});
如果then方法参数未提供resolve或者reject，会有一个默认的函数生成，如下例：
Promise.resolve(2).then(
//function(v){
// return v;
//}
null,
function() {
console.log(1);
}).then(function(v) {
console.log(v); //
},
//默认错误处理函数
//function(err) {
// throw err;
//}
);
小结：1、调用Promise.resolve(..)与then(..)总会返回一个Promise。
2、决议后返回的值可以通过链式调用解决掉。