1. promise定义
Promise是异步编程的一种解决方案，比传统的解决方案（函数回调和事件）更合理，更强大。ES6中将Promise写进了语言标准，统一了用法，提供原生的Promise对象。
Promise是一个容器，容器中保存着摸个未来才会结束的事件，通常是一个异步操作。从语法上看，Promise是一个对象，从它可以获取异步操作的消息。Promise提供统一的API，各种异步操作可以用同样的方法来处理。
Promise对象有以下两个特点：
1. 对象状态不受外界影响。Promise对象代表一个异步操作，有以下三个状态：
pending：进行中
fulfilled：已成功
reject： 已失败
只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是Promise名字的由来，它意思是“一个承诺”，表示其他手段无法改变。
2. 一旦改变状态，就不会再变，任何时候都可以得到这个结果。Promise对象的状态改变，只能有两种可能：从pending变成fulfilled和从pending变成rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果，这时就称为resolved（已定型）。如果改变已经发生，再对Promise对象添加回调函数，也会立即得到这个结果。这和事件完全不同，事件的特点是，如果错过了它，再去监听，是得不到任何结果的。
注意我们这里说resolved，后面如果没有特别说明，都是指fulfilled状态，不包含rejected状态。
有了Promise对象，我们就可以将异步操作以同步操作的流程表达出来，从而避免层层嵌套的回调函数。此外，Promise对象提供统一的接口，使得控制异步操作更加容易。
Promise也有一些缺点。首先无法取消Promise，一旦新建它就要立即执行，无法中途取消。其次，如果不设置回调函数，Promise内部抛出的错误，不会反映到外部。第三，当处于pending状态时，无法得知目前进展到哪一个状态，是刚刚开始还是即将完成。
2. 用法
在ES6中，Promise是一个构造函数，用来生成Promise实例。如下代码：
let promise = new Promise((resolve, reject) => {
if (/** 异步操作成功 */) {
resolve (value)
} else {
reject (error)
}
})
Promise构造函数接受一个函数作为参数，这个函数的两个参数分别是resolve和reject。resolve，reject是两个函数，是JavaScript引擎提供的，不用自己部署。resolve函数的作用是，将Promise对象的状态从pending改为resolved，在异步函数操作成功的时候调用给，并将异步操作的结果作为参数传递出去。reject函数的作用是将Promise对象的状态从pending改为rejected，在异步操作失败的时候调用，并将异步操作报出的错误作为参数传递出去。
Promise实例生成之后，可以用then方法来分别指定resolved状态和rejected状态的回调函数，下面是一个简单的例子：
function timeout (ms) {
return new Promise((resolve, reject) => {
/*setTimeout方法可以接受三个参数，第一个是要执行的代码或者函数，第二个是毫秒数，后面所有的参数都是给第一个参数（函数）传递的参数*/
setTimeout(resolve, ms, 'done')
})
};
timeout(1000).then(value => {
console.log(value);
});
1. timeout方法返回一个Promise实例，表示一段时间后才会发生的结果
2. 过了指定ms指定的时间后，Promise实例的状态就会变为resolved，然后触发then方法指定的回调函数
3. then方法指定的回调函数中输出setTimeout方法传递的第三个参数“done”
通过下面的代码看看Promise对象的执行顺序：
let promise = new Promise((resolve, reject) => {
console.log('Promise');
resolve();
});
promise.then(() => {
console.log('Resolved');
});
console.log('Hi');
1. 实例化一个Promise对象，调用构造函数，首先执行console.log('Promise');输出“Promise”，resolve()函数将Promise对象的状态从pending改为resolved
2. 使用then方法指定resolved状态回调函数
3. 输出“Hi”
4. 当期脚本所有同步任务执行完成后，执行then方法指定的回调函数，输出“resolved”
下面代码是使用Promise包装一个异步加载图片的方法：
function loadImageAsync (url) {
return new Promise((resolve, reject) => {
let image = new Image();
console.log(image)
image.onload = function () {
resolve(image);
};
image.onerror = function () {
reject(new Error('Could not load image at ' + url))
};
image.src = url;
})
}
loadImageAsync('https://avatar.csdn.net/2/1/1/3_m0_37682004.jpg').then(image => {
document.body.appendChild(image);
});
1. 定义loadImageAsync方法，在方法内部返回Promise对象
2. Promise函数内先定义一个image对象，image加载成功的时候调用resolve函数，将状态从pending改为resolved，加载失败的时候将调用reject函数，将状态从pending改为rejected。注意image对象有onload，onerror这两个回调函数。
3. 设置image对象的url
4. 调用loadImageAsync方法并用then方法指定Promise对象状态变为resolved时的回调函数，将image对象放在当前页面的body中
执行结果如下：
![]()
下面代码是一个用Promise实现Ajax操作的例子。getJSON是针对XMLHttpRequest对象的封装，用于发出一个针对JSON数据的HTTP请求，并返回一个Promise对象。注意在getJSON内部，resolve和rejecte函数调用时都带有参数，这个参数会传给then方法指定的函数。
let getJSON = function (url) {
let promise = new Promise((resolve, reject) => {
let client = new XMLHttpRequest();
client.open('GET', url);
client.onreadystatechange = handler;
client.responseType = 'json';
client.setRequestHeader('Accpt', 'application/json');
client.send();
function handler () {
if (this.readyState !== 4) {
return;
}
if (this.status === 200) {
resolve(this.response);
} else {
reject(new Error(this.statusText));
}
}
});
return promise;
}
getJson('posts.json').then(json => {
console.log(json);
}, error => {
console.log(`出错了`, error);
})
如果调用resolve函数和reject函数时带有参数，那么他们的参数会传递给回调函数。reject函数的参数通常是一个Error对象实例，表示抛出的错误。resolve函数的参数除了正常的值，还有可能是另外一个Promise实例，如下：
let p1 = new Promise(function (resolve, reject) {
});
let p2 = new Promise(function (resolve, reject) {
resolve(p1)
})
上面代码中，p1和p2都是Promise的实例，p2的resolve方法将p1作为参数，即一个异步操作的返回结果是另外一个异步操作。注意这是p1的状态会传递给p2，就是说p1的状态决定了p2的状态。如果p1的状态是pending，那么p2的回调函数就会等待p1的状态改变；如果p1的状态已经是resolved，那么p2的回调函数就会等待p1的状态改变；如果p1的状态是resolved或者rejected，那么p2的回调函数将会立即执行。
var p1 = new Promise((resolve, reject) => {
setTimeout(() => reject(new Error('fail')), 3000)
});
var p2 = new Promise((resolve, reject) => {
setTimeout(() => resolve(p1), 1000);
});
p2.then(result => console.log(result)).catch(error => console.log(error));
1. 定义Promise对象p1，3秒钟之后修改p1的状态为rejected
2. 定义Promise对象p2，1秒钟之后修改p2的状态为resolved，执行resolve函数的时候传递参数是对象p1，p1也是一个Promise对象，导致p2自己的状态无效，p2的状态由p1决定，这样p2回调函数不再有效，then方法指定resolve函数不再执行，而是执行p1的reject方法
3. 执行p2的then方法，p2的resolve方法不执行，3秒钟后捕捉到p1的Error，触发catch方法指定的回调函数，输出fail
调用resolve或者reject并不会终结Promise的参数函数的执行，如下代码：
new Promise((resolve, reject) => {
resolve(1);
console.log(2);
}).then(r => {
console.log(r);
});
执行结果如下：
![]()
1. 定义Promise对象，先把promise对象的状态修改为resolve，输出2，由于resolved的Promise是在本轮事件循环的末尾执行，总是晚于本轮循环的同步任务，因此先输出2
2. 使用then方法指定Promise对象的的resolve方法输出1
3.Promise.prototype.then()
Promise实例有then方法，then方法定义在原型对象Promise.prototype上。它的作用是为Promise实例添加状态改变时的回调函数。then方法的第一个参数是resolved状态的回调函数，第二个参数是可选的，是rejected状态的回调函数。
then方法返回的是一个新的Promise实例，这个实例不是原来的那个Promise实例，因此可以使用链式写法，即then方法后面再调用另外一个then方法。
let getJson = function (url) {
let promise = new Promise((resolve, reject) => {
let client = new XMLHttpRequest();
client.open('GET', url);
client.onreadystatechange = handler;
client.responseType = 'json';
client.setRequestHeader('Accpt', 'application/json');
client.send();
function handler () {
if (this.readyState !== 4) {
return;
}
if (this.status === 200) {
resolve(this.response);
} else {
reject(new Error(this.statusText));
}
}
});
return promise;
}
getJson('posts.json').then(function (post) {
return getJson(post.commentURL);
}).then(function funcA (comments) {
console.log("Resolved: ", comments);
}, function funcB (err) {
console.log("Rejected: ", err);
});
上面代码中用的posts.json文件内容如下：
{
"commentURL": "posts.json"
}
输出结果如下：
![]()
代码分析如下：
1. 定义getJson方法
2. 调用getJson方法，resolve回调函数中又调用getJson方法（传递的参数是posts.json中的commentURL属性值），并返回这个Promise对象
3. 第二个then方法中会等待第一个then方法返回的Promise对象状态变化，如果变为resolved就调用funcA，如果状态变为rejected，就调用funcB
上面的代码可以使用箭头函数，这样看起来更简洁，如下：
getJson('posts.json').then(
post => getJson(post.commentURL)
).then(
comments => console.log('resolved', comments),
err => console.log('rejected', err)
);
注意：
1. 箭头函数表达式笔函数表达式更加简洁，没有自己的this，arguments，auper，常用来那些本来需要匿名函数的地方，并且不能用作构造函数。
2. (参数1, 参数2, …, 参数N) => 表达式（单一）相当于 (参数1, 参数2, …, 参数N) =>{ return 表达式; }
4. Promise.property.catch()
Promise.property.catch()方法是Promise.property.then(null, rejection)的别名，用于指定Promise对象从pending变成reject时的回调函数。
getJson('posts.json').then(function (posts) {
}).catch(error => {
console.log('发生了错误', error)
})
上面代码中给，getJson方法返回的是一个Promise对象，如果该对象状态改变为resolved，则会调用then方法指定的回调函数；如果抛出错误，状态会变为rejected，就会调用catch方法指定的回调函数。另外then指定的回调函数中抛出错误，也会被catch捕获。看下面的代码：
var p = new Promise((resolve, reject) => {
if (true) {
resolve('fufilled')
} else {
reject()
}
});
p.then(val => console.log('fulfilled:', val))
.then(null, err => console.log('rejected:', err))
// 等同于
p.then(val => console.log('fulfilled:', val))
.catch(err => console.log('rejected', err));
输出结果如下：
![]()
上面代码中，promise抛出一个错误，就被catch方法指定的回调函数捕获。注意着两种写法是等价的。再看下面两种写法
const promise1 = new Promise((resolve, reject) => {
try {
throw new Error('test');
} catch (e) {
reject(e)
}
});
promise1.catch(error => {
console.log(error);
});
const promise2 = new Promise((resolve, reject) => {
reject(new Error('text'));
})
promise2.catch(error => console.log(error));
输出结果如下：
![]()
1. 定义Promise对象promise1，抛出Error，在catch语句中将当前对象状态从pending修改为rejected，并传递错误对象
2. 执行catch方法，输出错误对象
3. 定义Promise对象promise1，直接将当前状态从pending修改为rejected并将错误对象作为参数传递
4. 执行catch方法，输出错误对象
比较上面两种写法，可以说reject方法的作用等同于冒出错误。
如果Promise状态已经修改为resolved，则再抛出错误是无效的，看下面代码：
const promise = new Promise((resolve, reject) => {
resolve('ok')
throw new Error('test')
})
promise.then(value => console.log(value))
.catch(error => console.log(error))
输出结果如下：
![]()
1. 定义Promise对象，在方法中先调用resolve方法将状态从pending修改为resolved，并传递参数“ok”，再抛出错误。注意抛出错误的语句写在resolve后面，不会被捕获，等于没有抛出。因为Promise的状态一旦改变就永远不会再变了。
2. 在then方法中，添加状态变为resolved的回调方法，输出参数值“ok”
3. 在catch方法中，添加状态变为rejected的回调方法，输出错误。定义Promise对象的方法中没有调用reject方法，这里不会被调用
那如果在定义Promise对象的方法中既没有调用resolve方法，也没有调用reject方法，只抛出错误会怎么样呢？ 看看下面的代码：
const promise = new Promise((resolve, reject) => {
throw new Error('test')
})
promise.catch(error => console.log(error))
// 等同于
promise.then(null, error => console.log(error))
结果如下：
![]()
看来不仅仅是reject方法会把状态修改为rejected，抛出错误也可以。
Promise对象的错误具有冒泡性质，会一直向后传递，知道捕获为止，就是说，错误会被下一个catch语句捕获。
getJson('/post/1.json').then(function(post) {
return getJSON(post.commentURL);
}).then(function(comments) {
// some code
}).catch(function(error) {
// 处理前面三个Promise产生的错误
});
上面代码中，一共有三个Promise对象，一个由getJson产生，两个由then产生。它们之中任何一个抛出错误，都会被最后一个catch捕获。
一般来说，不要在then方法中定义Reject状态的回调函数，即then方法的第二个参数，总是使用catch方法
// bad
promise
.then(function(data) {
// success
}, function(err) {
// error
});
// good
promise
.then(function(data) { //cb
// success
})
.catch(function(err) {
// error
});
上面代码中，第二种写法要好于第一种，理由是第二种写法可以捕获前面then方法执行中的错误，也更接近于同步的写法（try/catch）。因此，建议总是使用catch方法，而不是使用then方法的第二个参数。
和传统的try/catch代码块不同的是，如果没有使用catch方法指定错误处理的回调函数，Promise对象抛出的错误不会传递到外层代码，即不会有任何反应。看下面的代码：
const someAsyncThing = function() {
return new Promise(function(resolve, reject) {
// 下面一行会报错，因为x没有声明
resolve(x + 2);
});
};
someAsyncThing().then(function() {
console.log('everything is great');
});
setTimeout(() => { console.log(123) }, 2000);
输出结果如下：
![]()
1. 定义someAsyncThing方法，返回一个Promise对象
2. 调用resolve方法，传递参数中报错，浏览器执行到这里会报错并打印错误提示：Uncaught (in promise) ReferenceError: x is not defined，但是不会退出进程，最终脚本停止执行
3. 使用then方法定义resolved状态回调函数，输出“everything is great”
4. 3秒钟之后输出：123，Promise内部的错误不会影响到后面代码的执行，通俗的说是Promise会吃掉错误
虽然Promise对象方法中调用的是resolve方法，但是报错的代码会将Promise对象的状态从pending修改为rejected，then方法中定义的resolve回调函数不会执行。看下面的代码：
const someAsyncThing = function() {
return new Promise(function(resolve, reject) {
// 下面一行会报错，因为x没有声明
resolve(x + 2);
});
};
someAsyncThing().then(function() {
console.log('everything is great');
}).catch(e => console.log(e));
setTimeout(() => { console.log(123) }, 2000);
输出结果如下：
![]()
从输出结果我们看到，catch方法定义的语句输出了错误内容，这个时候就不是红色的字体了，而是正常的console.log()输出。
把上面代码放在服务器执行，退出码就是0，表示执行成功 。不过Node有一个unhnadledRejection事件，专门监听未捕获的reject错误，上面的脚本就会触发这个事件监听函数，可以在监听函数中抛出错误。
process.on('unhandledRejection', function (err, p) {
throw err;
});
上面代码中，unhandledRejection事件的监听函数有两个参数，第一个是错误对象，第二个是报错的Promise实例，它可以用来了解错误的环境信息。
注意，Node有计划在未来废除这个unhandledRejection事件。如果Promise内部有未捕获的错误，会直接终止进程，并且进程的退出码不会0
const promise = new Promise((resolve, reject) => {
resolve('ok');
setTimeout(() => { throw new Error('test') }, 0)
})
promise.then(value => { console.log(value) })
结果如下：
![]()
上面代码中，Promise指定在下一轮“事件循环”再抛出错误。到那个时候，Promise的运行状态已经结束了，所以这个错误是在Promise函数体外抛出的，会冒泡到最外层，成了未捕获的错误。
再看下面的代码：
const promise = new Promise((resolve, reject) => {
resolve('ok')
console.log('test')
throw new Error('test')
})
promise.then(value => {
console.log(value)
}).catch(e => console.log(e))
输出结果如下：
![]()
上面代码中调用resolve方法之后，先输出“test”，再抛出错误，但是会被忽略掉。
看下面代码：
const promise = new Promise((resolve, reject) => {
resolve('ok')
throw new Error('test')
console.log('test')
})
promise.then(value => {
console.log(value)
}).catch(e => console.log(e))
输出结果如下：
![]()
上面代码中调用resolve方法之后，先抛出错误，之后程序就不再往下执行了，后面的console.log('test')不会执行
一般总是建议，Promise对象后面要跟catch方法，这样可以处理Promise的内部发生的错误。catch方法返回的还是一个Promise对象，因此后面还可以调用then方法。看下面代码：
const someAsyncThing = function () {
return new Promise((resolve, reject) => {
resolve(x + 2)
})
}
someAsyncThing().catch(error => console.log('oh on', error))
.then(() => console.log('carry on'))
执行结果如下：
![]()
上面代码运行完catch方法指定的回调函数之后，会接着执行后面的then方法指定的回调函数，如果没有报错，会跳过then方法。这说明这里catch返回的promise的状态是resolved，不是rejected
看下面的代码：
Promise.resolve()
.catch(error => console.log('oh no', error))
.then(() => console.log('carry on'))
执行结果如下：
![]()
上面代码因为代码没有报错，跳过了catch方法，直接执行后面的then方法。此时，要是then方法里面报错了，就和前面的catch无关了。
catch方法中还能再次抛出错误，如下代码：
const someAsyncThing = function () {
return new Promise((resolve, reject) => {
resolve(x + 2)
})
}
someAsyncThing().then(() => someAsyncThing())
.catch(error => {
console.log('oh no', error)
// 下面语句报错，y是没有定义的
y + 2
}).then(() => {
console.log('carry on');
})
输出结果如下：
![]()
上面代码中，catch方法抛出一个错误，因为后面没有别的catch方法了，导致这个错误不会被捕获，也捕获传递到外城。下面改写一下：
const someAsyncThing = function () {
return new Promise(function (resolve, reject) {
// 下面一行会报错，因为x没有声明
resolve(x + 2);
});
};
someAsyncThing().then(function () {
return someOtherAsyncThing();
}).catch(function (error) {
console.log('oh no', error);
// 下面一行会报错，因为y没有声明
y + 2;
}).catch(function (error) {
console.log('carry on', error);
});
输出结果如下：
![]()
上面代码中，第二个catch方法用来捕获第一个catch方法抛出的错误。
5. Promise.property.finally()
finally方法用于指定不管Promise对象最后状态如何，都会被执行的操作。这个方法是ES2018引入标准的。
Promise.resolve('resolve')
.then(result => console.log(result))
.catch(e => console.log(e))
.finally(() => console.log('finally'))
上面代码中，不管promise最后的状态，在执行完then之后或者catch指定的回调函数以后，都会执行finally方法指定的回调函数。
finally方法的回调函数不接受任何参数，这意味着没有办法知道，前面的Promise对象的状态到底是fulfilled还是rejected。这表明，finally方法里的操作是和状态无关的，不依赖于Promise的执行结果。
finally方法本质上是then方法的特例
promise
.finally(() => {
// 语句
});
// 等同于
promise
.then(
result => {
// 语句
return result;
},
error => {
// 语句
throw error;
}
);
上面代码中，如果不适用finally方法，同样的语句需要为成功和失败两种情况各写一次。有了finally方法，则只需要写一次。
它的实现也很简单。
Promise.prototype.finally = function (callback) {
let p = this.constructor
return this.then(
value => P.resolve(callback()).then(() => value),
reason => p.resolve(callback()).then(() => { throw reason })
)
}
从上面代码可以看到，不管前面Promise是fulfilled还是rejected，都会执行回调函数callback。
finally方法总是返回原来的值。
6. Promise.all()
Promise.all()方法用于将多个Promise实例，包装成一个新的Promise实例。const p = Promise.all([p1, p2, p3])，Promise.all方法接受一个数组作为参数，p1，p2，p3都是Promise的实例，如果不是，就会先调用下面讲到的Promise.resolve()方法，将参数转为Promise实例，再进一步处理。Promise.all方法的参数可以不是数组，但是必须有Iterator接口，且返回的每个成员都是Promise实例。
（1）只有p1，p2，p3的状态都变成fulfilled，p的状态才会变成fulfilled，此时p1，p2，p3的返回值组成一个数组，传递给p的回调函数
（2）只要p1，p2，p3之中有一个被rejected，p的状态就变成rejected，此时第一个被rejected的实例的返回值，会传递给 p的回调函数。注意其他的对象完全被忽略掉。
下面是一个例子
// 生成一个Promise对象的数组
const promises = [2, 3, 5, 7, 11, 13].map(function (id) {
return getJSON('/post/' + id + ".json");
});
Promise.all(promises).then(function (posts) {
// ...
}).catch(function(reason){
// ...
});
上面代码中，promise是包含6个Promise实例的数组，只有这6个实例的状态都变成fulfilled，或者其中一个变成rejected，才会调用Promise.all方法后面的回调函数。
下面是另一个例子：
const databasePromise = connectDatabase();
const booksPromise = databasePromise
.then(findAllBooks);
const userPromise = databasePromise
.then(getCurrentUser);
Promise.all([
booksPromise,
userPromise
])
.then(([books, user]) => pickTopRecommentations(books, user));
上面代码中，booksPromise和userPromise是两个异步操作，只有等到他们的结果都返回了，才会触发pickTopRecommentation这个回调函数。
注意，如果作为参数的Promise实例，自己定义了catch方法，那么它一旦被rejected，并不会触发Promise.all()的catch方法。
const p1 = new Promise((resolve, reject) => {
resolve('hello');
}).then(result => result)
.catch(e => e);
const p2 = new Promise((resolve, reject) => {
throw new Error('报错了');
}).then(result => result)
.catch(e => e);
Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
执行结果如下：
![]()
1. 定义Promise对象p1，修改状态为resolved，向回调函数传递参数“hello”，then方法指定的回调函数中返回这个参数，catch方法定义的回调函数中返回异常
2. 定义Promise对象p2，抛出异常“报错了”，then方法指定的回调函数中返回输入参数，catch方法指定的回调函数返回当前异常
3. 使用Promise.all方法将p1，p2包装成一个新的Promise对象，p1先resolved，p2先rejected，但是p2有自己的catch方法，catch方法返回新的Promise实例，p2指向的实际上是这个实例。该实例执行完catch方法后，也会变成resolved，导致Promise.all方法参数里面两个实例都会resolved，因此会调用then方法中指定的回调函数，而不会调用catch方法指定的回调函数。
4.最后输出了p1，p2的结果，结果也是一个数组，第一个是“hello”，第二个是p2抛出的错误。
如果p2没有自己的catch方法，就会调用Promise.all的catch方法，并将Error传递给p的回调函数。看下面代码：
const p1 = new Promise((resolve, reject) => {
resolve('hello');
}).then(result => result)
const p2 = new Promise((resolve, reject) => {
throw new Error('报错了');
}).then(result => result)
Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
输出结果如下：
![]()
上面代码中，Promise对象p2中冒出异常，状态从pending修改为rejected，此时第一个被rejected的实例的返回值Error传递给p的catch方法指定的回调函数，输出这个Error，而p1完全被忽略掉，两个对象p1，p2和一个对象p2的效果是一样的。
7.Promise.race()
Promise.race()方法同样是将多个Promise对象实例，包装成一个新的Promise实例。const p = Promise.race([p1, p2, p3]); 这句代码中p1，p2，p3只要有一个实例率先改变状态，p的状态就跟着改变，那个率先改变的Promise实例的返回值，就传递给p的回调函数。
Promise.race()方法的参数和Promise.all()方法完全一样，如果不是Promise实例，就会先调用下面介绍的Promise.resolve方法，将参数转为Promise实例，进一步处理。
下面是一个例子，如果指定事件内没有获得结果，就将Promise的状态改变为rejected，否则转变为resolved。
const p = Promise.race([
fetch('/resource-that-may-take-a-while'),
new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('request timeout')), 5000)
})
]);
p.then(console.log)
.catch(console.error);
上面代码中，如果5秒内fetch方法没有返回结果，变量p的状态就变成了rejected从而触发catch方法指定的回调函数。这个和ajax方法中的timeout参数效果类似。
8.Promise.resolve()
有时候需要将现有对象转换成Promise对象，Promise.resolve()方法就起到这个作用。const jsPromise = Promise.resolve($.ajax('/posts.json')); 这一句代码将jQuery生成的deferred对象，转为一个新的Promise对象。Promise.resolve()方法等同于new Promise(resolve => resolve('foo'))，接受一个参数，实例化一个Promise对象。
Promise.resolve方法的参分成四种情况。
（1）参数是一个Promise实例
如果参数是Promise实例，那么Promise.resolve将不做任何修改，原封不动的返回这个实例
（2）参数是一个thenable对象
thien对象是指具有then方法的对象，比如下面的对象：
let thenable = {
then: function (resolve, reject) {
resolve(42);
}
};
Promise.resolve方法将这个对象转为Promise对象，然后立即执行thenable对象的then方法
let thenable = {
then: function (resolve, reject) {
resolve(42);
}
};
let p1 = Promise.resolve(thenable);
console.log(p1);
p1.then(function (value) {
console.log(value);
console.log(p1)
});
console.log(p1);
执行结果如下：
![]()
上面代码中，thenable对象的then方法执行后，对象p1的状态就变为resolved，从而立即执行最后那个then方法指定的回调函数，输出42
（3）参数不是thenable对象，或根本不是对象
如果参数是一个原始值，或者是一个不具有then方法的对象，则Promise.resolve方法返回一个新的Promise对象，状态为resolved。
var p = Promise.resolve('Hello');
console.log(p)
p.then(function (s) {
console.log(s)
})
执行的结果如下：
![]()
上面代码生成一个新的Promise对象的实例p。由于字符串Hello不属于异步操作（判断字符串是否具有then方法），返回Promise实例的状态从实例化开始就是resolved，所以回调函数就立即执行。Promise.resolve方法的参数，会同时传给回调函数。
（4）不带任何参数
Promise.resolve方法允许不带任何参数，直接返回一个resolved状态的Promise对象。所以如果希望得到一个Promise对象，比较方便的方法就是直接调用Promise.resolve方法。
setTimeout(function () {
console.log('three');
}, 0);
Promise.resolve().then(function () {
console.log('two');
});
console.log('one');
输出结果如下：
![]()
需要注意的是，立即resolve的Promise对象，是在本轮“事件循环” （event loop）结束时，而不是在下一轮“事件循环”的开始时。上面代码中setTimeOut(fn, 0)在下一轮“事件循环”开始时执行，Promise.resolve()在本轮“事件循环”结束时执行，console.log('one')则是立即执行。
9.Promise.reject()
Promise.reject()方法也返回一个新的Promise实例，改实例的状态为rejected。
const p = Promise.reject('出错了');
//等同于
const p = new Promise((resolve, reject) => reject('出错了'))
p.then(null, function (s) {
console.log(s);
});
输出结果为：
![]()
上面代码生成了一个Promise对象实例p状态为rejected，回调函数会立即执行。注意Promise.reject()方法的的参数，会原封不动地作为reject的理由，变成后续方法的参数。这一点与Promise.resolve方法不一致。
const thenable = {
then(resolve, reject) {
reject('出错了');
}
};
Promise.reject(thenable)
.catch(e => {
console.log(e === thenable)
})
代码输出结果为：
![]()
上面代码中，Promise.reject方法的参数是一个thenable对象，执行以后，后面的catch方法的参数不是reject熬出的“出错了” 这个字符串，而是thenable对象。
11. Promise.try()
实际开发过程中，经常遇到一种情况，不知道或者不想区分，函数f是同步函数还是异步操作，但是想用Promise来处理它。因为这样可以不管f是否包含异步操作，都用thenable方法指定下一步流程，用catch方法处理f抛出的错误，一般会采用Promise.resolve().then(f);这种方法。
这种写法有一个缺点，就是如果f是同步函数，那么它会在本轮事件循环的末尾执行。
const f = () => console.log('now');
Promise.resolve().then(f);
console.log('next');
输出结果如下：
![]()
1. 定义函数f，输出“now”
2. 使用Promise.resolve()方法包装函数f，在then方法中调用f，f在本轮事件循环的末尾执行
3. 直接输出“next”
有没有办法让异步函数异步执行，同步函数同步执行，并且使用同一的API呢？可以使用async方法，代码如下：
const f = () => console.log('now');
(async () => f())();
console.log("next");
执行结果如下：
![]()
上面代码中，第二行是一个立即执行的匿名函数，会立即执行里面的async函数，因此如果f是同步的，就会得到同步的结果；如果f是异步的，就可以用then指定下一步。就像下面的写法：
(async () => f())()
.then(...)
需要注意的是，async() => f()会吃掉f()跑出的错误。所以如果想捕获错误，就要使用promise.catch方法
(async () => f())()
.then(...)
.catch(...)
第二种写法是使用new Promise()
const f = () => console.log('now');
(
() => new Promise(
resolve => resolve(f())
)
)();
console.log('next');
输出结果如下：
![]()
下面的代码也是使用立即执行的的匿名函数，所以现在有一提案，提供Promise.try代替上面的写法。
const f = () => console.log('now');
Promise.try(f);
console.log('next');
由于Promise.try为所有操作提供同一的处理机制，所以如果想用then方法管理刘晨个，最好是使用Promise.try包装一下，这样可以更好的处理异常。
function getUsername(userId) {
return database.users.get({id: userId})
.then(function(user) {
return user.name;
});
}
上面代码中，database.user.get()返回一个Promise对象，如果跑出异常错误，可以使用catch方法捕获，如下：
database.users.get({id: userId})
.then(...)
.catch(...)
但是database.users.get()可能还会抛出同步错误（比如数据库连接错误，具体要看实现的方法），这时就不得不使用try...catch捕获。
try {
database.users.get({id: userId})
.then(...)
.catch(...)
} catch (e) {
// ...
}
上面的写法很笨拙，这时就可以统一用promise.catch()捕获所有同步和异步的错误。
作者：Tyler Ning
出处：http://www.cnblogs.com/tylerdonet/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，如有问题，可以通过以下邮箱地址williamningdong@gmail.com 联系我，非常感谢。
