本文详细解析 ES6 中 Promise 的核心机制，涵盖从 Pending 到 Resolved/Rejected 的状态流转规则。重点讲解 then 方法的链式调用原理、返回值处理及异常捕获机制，并对比 Promise.all 与 Promise.race 在并发与竞态场景下的应用差异，结合代码示例说明常见用法与错误模式。
Promise 基础与状态机制
Promise 是 ES6 引入的核心特性，旨在规范异步任务的回调处理流程，其功能定位类似于 jQuery 中的 deferred 对象。简而言之，它通过 Promise 对象的不同状态来触发相应的回调函数。需要注意的是，IE8 及更低版本的浏览器不支持该特性，而现代主流浏览器均已提供支持。
Promise 对象拥有三种状态：Pending（进行中）、Resolved（已完成）和 Rejected（已失败）。一旦状态从 Pending 转换为 Resolved 或 Rejected，该 Promise 对象的状态将永久固定，不再发生任何改变。
使用 Promise 的基本步骤如下：
var promise = new Promise(function(resolve, reject) {
// 异步任务，通过调用resolve(value) 或 reject(error)，以改变promise对象的状态；改变状态的方法只能在此调用。
//promise状态改变后，会调用对应的回调方法
});
promise.then(function(value){//resolve时的回调函数，参数由异步的函数传进来})
.catch(function(error){//发生异常时或明确reject()时的回调函数})
Promise 基本用法与异步特性
具体使用场景与代码示例如下：
function getURL(URL) { //因为promise创建时即执行，所以用工厂函数封装promise对象
return new Promise(function (resolve, reject) {
var req = new XMLHttpRequest();
req.open('GET', URL, true);
req.onload = function () {
if (req.status === 200) {
resolve(req.responseText);
} else {
reject(new Error(req.statusText));
}
};
req.onerror = function () {
reject(new Error(req.statusText));
};
req.send();
});
}
// 运行示例
var URL = "http://httpbin.org/get";
getURL(URL).then(function onFulfilled(value){
console.log(value);
}).catch(function onRejected(error){
console.error(error);
});
需要明确的是，Promise 的回调函数始终以异步方式执行，即使注册时 Promise 状态已变为 Resolved，其回调也会放入事件队列异步执行，而非同步立即调用。
var promise = new Promise(function (resolve){
console.log("inner promise"); // 执行1：同步任务先执行
resolve(‘callBack');
});
promise.then(function(value){
console.log(value); // 执行3:虽然注册时状态为resolved，但回调仍是异步的；
});
console.log("outer promise"); // 执行2：同步代码先执行
链式调用与异常处理
Promise 的方法链式调用机制如下：
在链式调用中，then 方法注册的回调会依次执行，前一个 then 的返回值会作为参数传递给下一个 then。若某个回调中抛出异常，会跳过后续同级的 then 回调，直接触发 catch 回调；catch 执行完毕后，链式调用会继续执行剩余的 then 回调。值得注意的是，在 then(onFulfilled, onRejected) 中，onFulfilled 内部抛出的异常无法被自身的 onRejected 捕获，因此建议优先使用 catch 来处理错误。
典型的链式调用结构为：promise.then(taskA).then(taskB).catch(onRejected).then(finalTask);
若 taskA 抛出异常，taskB 将被跳过，但 finalTask 仍会被执行。这是因为 catch 返回的 Promise 对象状态为 Resolved，从而保证了后续 then 回调的正常触发。
在 then 方法内部，可以返回以下三种类型的值：
1. 返回另一个 Promise 对象：下一个 then 方法将根据该新 Promise 的状态（Resolved 或 Rejected）选择执行 onFulfilled 或 onRejected 回调，参数由新 Promise 的 resolve 或 reject 方法传递。
2. 返回一个同步值：下一个 then 方法将沿用当前 Promise 对象的状态，无需等待异步任务结束即可立即执行。此时传入的参数为上一个 then 的返回值；若未显式 return，则默认返回 undefined。
3. 抛出异常（同步或异步）：例如通过 throw new Error('xxx') 显式抛出错误。
then 方法不仅注册回调，还会对回调函数的返回值进行变换，并创建和返回一个新的 Promise 对象。这意味着在方法链中，每一步操作实际上都在处理不同的 Promise 实例，而非同一个对象。
var aPromise = new Promise(function (resolve) {
resolve(100);
});
var thenPromise = aPromise.then(function (value) {
console.log(value);
});
var catchPromise = thenPromise.catch(function (error) {
console.error(error);
});
console.log(aPromise !== thenPromise); // => true
console.log(thenPromise !== catchPromise);// => true
并发控制：Promise.all 与串行执行
Promise.all() 是一个静态方法，用于并发执行多个异步任务。只有当接收到的所有 Promise 对象都变为 Resolved 或 Rejected 状态后，才会执行后续的 then 处理逻辑。
Promise.all([promiseA, promiseB]).then(function(results){//results是个数组，元素值和前面promises对象对应});
// 由promise对象组成的数组会同时执行，而不是一个一个顺序执行，开始时间基本相同。
function timerPromisefy(delay) {
console.log('开始时间：”'+Date.now())
return new Promise(function (resolve) {
setTimeout(function () {
resolve(delay);
}, delay);
});
}
var startDate = Date.now();
Promise.all([
timerPromisefy(100), //promise用工厂形式包装一下
timerPromisefy(200),
timerPromisefy(300),
timerPromisefy(400)
]).then(function (values) {
console.log(values); // [100，200，300，400]
});
与 Promise.all 不同，以下场景演示了串行执行 Promise 的方式，即一个接一个地依次执行。
//promise factories返回promise对象,只有当前异步任务结束时才执行下一个then
function sequentialize(promiseFactories) {
var chain = Promise.resolve();
promiseFactories.forEach(function (promiseFactory) {
chain = chain.then(promiseFactory);
});
return chain;
}
竞态处理：Promise.race 与定时器应用
Promise.race() 的行为与 Promise.all() 类似，但 race() 只要有一个 Promise 对象进入 Resolved 或 Rejected 状态，就会立即执行对应的回调函数。需要注意的是，第一个 Promise 变为 Resolved 后，并不会影响其他 Promise 对象的继续执行。
//沿用Promise.all()的例子
Promise.race([
timerPromisefy(1),
timerPromisefy(32),
timerPromisefy(64),
timerPromisefy(128)
]).then(function (value) {
console.log(values); // [1]
});
利用 Promise.race() 可以实现定时器的功能，例如设置超时中断。
Promise.race([
new Promise(function (resolve, reject) {
setTimeout(reject, 5000); // timeout after 5 secs
}),
doSomethingThatMayTakeAwhile()
]);
状态传递与结果获取规范
在 then 回调中修改 Promise 状态的方法如下：
由于 then 的回调函数仅接收 value 参数，而没有直接改变状态的方法（状态改变只能在构造函数中的异步任务里进行），若需改变传递给下一个 then 的 Promise 对象状态，必须重新 new 一个新的 Promise 对象，在异步任务中判断状态并 resolve/reject，最后 return 该新 Promise 以传递给后续的 then 或 catch。
var promise = Promise.resolve(‘xxx');//创建promise对象的简介方法
promise.then(function (value) {
var pms=new Promise(function(resolve,reject){
setTimeout(function () {
// 在此可以判断是否改变状态reject/resolve
Reject(‘args')；
}, 1000);
})
return pms; //该promise对象可以具有新状态，下一个then/catch需要等异步结束才会执行回调；如果返回普通值/undefined，之后的then/catch会立即执行
}).catch(function (error) {
// 被reject时调用
console.log(error)
});
获取多个 Promise 结果的常用方式如下：
//方法1：通过在外层的变量传递
var user;
getUserByName('nolan').then(function (result) {
user = result;
return getUserAccountById(user.id);
}).then(function (userAccount) {
//可以访问user和userAccount
});
//方法2：后一个then方法提到前一个回调中
getUserByName('nolan').then(function (user) {
return getUserAccountById(user.id).then(function (userAccount) {
//可以访问user和userAccount
});
});
使用 Promise 时需注意整体代码结构的规范性。
假设 doSomething() 和 doSomethingElse() 函数均返回 Promise 对象。
推荐的常用写法为：
doSomething().then(doSomethingElse).then(finalHandler);
doSomething
|-----------------|
doSomethingElse(resultOfDoSomething) //返回新promise，下一个then要收到新状态才执行
|------------------|
finalHandler(resultOfDoSomethingElse)
|---------------------|
常用的变通写法包括：
doSomething().then(function () { return doSomethingElse();}).then(finalHandler);
doSomething
|-----------------|
doSomethingElse(undefined) //then外层函数的arguments[0]== resultOfDoSomething
|------------------|
finalHandler(resultOfDoSomethingElse)
|------------------|
常见的错误写法之一：
doSomething().then(function () { doSomethingElse();}).then(finalHandler);
doSomething
|-----------------|
doSomethingElse(undefined) //虽然doSomethingElse会返回promise对象，但最外层的回调函数是return undefined，所以下一个then方法无需等待新promise的状态，会马上执行回调。
|------------------|
finalHandler(undefined)
|------------------|
错误方式2：
doSomething().then(doSomethingElse()).then(finalHandler);
doSomething
|-----------------|
doSomethingElse(undefined) //回调函数在注册时就直接被调用
|----------|
finalHandler(resultOfDoSomething)
|------------------|