之前解析了core.js，接下来解析es6-extensions.js。这个文件包含了Promise的静态方法的实现。
// 特殊值转化成Promise对象，减少重复new实例。
var TRUE = valuePromise(true);
var FALSE = valuePromise(false);
var NULL = valuePromise(null);
var UNDEFINED = valuePromise(undefined);
var ZERO = valuePromise(0);
var EMPTYSTRING = valuePromise('');
function valuePromise(value) {
var p = new Promise(Promise._noop);
p._state = 1;
p._value = value;
return p;
}
// `Promise.resolve()` 静态方法将给定的值转换为一个 `Promise`
// 如果该值本身就是一个 Promise，那么该 Promise 将被返回；
// 如果该值是一个 thenable对象，`Promise.resolve()` 将调用其 `then()` 方法及其两个回调函数；
// 否则，返回的 Promise 将会以该值兑现。
Promise.resolve = function (value) {
if (value instanceof Promise) return value;
if (value === null) return NULL;
if (value === undefined) return UNDEFINED;
if (value === true) return TRUE;
if (value === false) return FALSE;
if (value === 0) return ZERO;
if (value === '') return EMPTYSTRING;
if (typeof value === 'object' || typeof value === 'function') {
try {
var then = value.then;
if (typeof then === 'function') {
return new Promise(then.bind(value));
}
} catch (ex) {
return new Promise(function (resolve, reject) {
reject(ex);
});
}
}
return valuePromise(value);
};
// 这段代码的目的是实现一个将可迭代对象转换为数组的方法。
// 这种写法的两个好处
// 1、不需要每次都做兼容性判断
// 2、不像IIFE，在还没调用的时候就完成了兼容性的判断
var iterableToArray = function (iterable) {
if (typeof Array.from === 'function') {
// ES2015+, iterables exist
iterableToArray = Array.from;
return Array.from(iterable);
}
// ES5, only arrays and array-likes exist
iterableToArray = function (x) { return Array.prototype.slice.call(x); };
return Array.prototype.slice.call(iterable);
}
// `Promise.all()`静态方法接受一个 Promise 可迭代对象作为输入，
// 并返回一个 `Promise`当所有输入的 Promise 都被兑现时，
// 返回的 Promise 也将被兑现（即使传入的是一个空的可迭代对象），
// 并返回一个包含所有兑现值的数组。
// 如果输入的任何 Promise 被拒绝，则返回的 Promise 将被拒绝，并带有第一个被拒绝的原因。
Promise.all = function (arr) {
var args = iterableToArray(arr);
return new Promise(function (resolve, reject) {
if (args.length === 0) return resolve([]);
var remaining = args.length;
function res(i, val) {
if (val && (typeof val === 'object' || typeof val === 'function')) {
// 如果是Promise类型
if (val instanceof Promise && val.then === Promise.prototype.then) {
// 找到最顶层的promise
while (val._state === 3) {
val = val._value;
}
// 如果是fulfilled状态，从新执行res，并将val._value作为结果值传递
// 之后，会执行args[i] =val，并将remaining计数减一
if (val._state === 1) return res(i, val._value);
// 如果是rejected状态，则调用reject，promise敲定。
if (val._state === 2) reject(val._value);
// 如果是pending态，则调用then方法，将上面两种状态需要执行的代码传入回调中。
val.then(function (val) {
res(i, val);
}, reject);
return;
} else {
// 同上。
var then = val.then;
if (typeof then === 'function') {
var p = new Promise(then.bind(val));
p.then(function (val) {
res(i, val);
}, reject);
return;
}
}
}
args[i] = val;
// 如果没有剩余参数，代表所有Promise都被对象，执行resolve
if (--remaining === 0) {
resolve(args);
}
}
for (var i = 0; i < args.length; i++) {
res(i, args[i]);
}
});
};
function onSettledFulfill(value) {
return { status: 'fulfilled', value: value };
}
function onSettledReject(reason) {
return { status: 'rejected', reason: reason };
}
function mapAllSettled(item) {
if(item && (typeof item === 'object' || typeof item === 'function')){
if(item instanceof Promise && item.then === Promise.prototype.then){
return item.then(onSettledFulfill, onSettledReject);
}
var then = item.then;
if (typeof then === 'function') {
return new Promise(then.bind(item)).then(onSettledFulfill, onSettledReject)
}
}
return onSettledFulfill(item);
}
// `Promise.allSettled()` 静态方法将一个 Promise 可迭代对象作为输入，并返回一个单独的 `Promise`。
// 当所有输入的 Promise 都已敲定时（包括传入空的可迭代对象时），
// 返回的 Promise 将被兑现，并带有描述每个 Promise 结果的对象数组。
// allSettled的实现是基于all的方法再做了一层参数的映射。
Promise.allSettled = function (iterable) {
return Promise.all(iterableToArray(iterable).map(mapAllSettled));
};
// 简单，不做赘述
Promise.reject = function (value) {
return new Promise(function (resolve, reject) {
reject(value);
});
};
// `Promise.race()` 静态方法接受一个 promise 可迭代对象作为输入，并返回一个 `Promise`。这个返回的 promise 会随着第一个 promise 的敲定而敲定。
Promise.race = function (values) {
return new Promise(function (resolve, reject) {
// 遍历所有值，当第一个promise敲定时，其它值无法再更新该返回promise的状态，因此resolve和reject只会被执行一次。
iterableToArray(values).forEach(function(value){
Promise.resolve(value).then(resolve, reject);
});
});
};
/* Prototype Methods */
// `catch`，只有reject回调的then方法
Promise.prototype['catch'] = function (onRejected) {
return this.then(null, onRejected);
};
function getAggregateError(errors){
if(typeof AggregateError === 'function'){
return new AggregateError(errors,'All promises were rejected');
}
var error = new Error('All promises were rejected');
error.name = 'AggregateError';
error.errors = errors;
return error;
}
// `Promise.any()` 静态方法将一个 Promise 可迭代对象作为输入，并返回一个 `Promise`。当输入的任何一个 Promise 兑现时，这个返回的 Promise 将会兑现，并返回第一个兑现的值。当所有输入 Promise 都被拒绝（包括传递了空的可迭代对象）时，它会以一个包含拒绝原因数组的 `AggregateError`拒绝。
Promise.any = function promiseAny(values) {
return new Promise(function(resolve, reject) {
var promises = iterableToArray(values);
var hasResolved = false;
var rejectionReasons = [];
// onFulfilled回调，当任意promise兑现，将标识设置为true，并调用resolve
function resolveOnce(value) {
if (!hasResolved) {
hasResolved = true;
resolve(value);
}
}
// 将错误入栈，如果错误集合长度等于入参长度，执行reject
function rejectionCheck(reason) {
rejectionReasons.push(reason);
if (rejectionReasons.length === promises.length) {
reject(getAggregateError(rejectionReasons));
}
}
if(promises.length === 0){
reject(getAggregateError(rejectionReasons));
} else {
promises.forEach(function(value){
Promise.resolve(value).then(resolveOnce, rejectionCheck);
});
}
});
};
