JavaScript Promise的6个核心特性与实战细节

Promises的多路分支（Forking）

Promises最强大的特性之一是能够基于同一个初始Promise创建多个独立的结果路径。这被称为“Forked Promise”模式，类似于流程图中的分叉点。理解这一点对于避免非预期的错误传播至关重要。

以下两段代码看似相似，但行为截然不同：

// 写法 A：独立的链式调用
var p = new Promise(/*...*/);
p.then(func1);
p.then(func2);

// 写法 B：标准的链式调用
var p = new Promise(/*...*/);
p.then(func1).then(func2);

• 写法A分析：每个then()调用都返回一个新的Promise。因此，func1和func2挂载在两个不同的新Promise上。如果func1()内部抛出异常，它只会导致第一个新Promise被拒绝，而func2()依然会正常执行。
• 写法B分析：func1的执行结果将传递给下一个then()。如果func1()抛出错误，返回的新Promise将被拒绝，导致func2()不会被调用（除非提供了明确的错误处理程序）。

总结

Promises允许并行处理相同的输入源，互不干扰。这种机制在处理需要并行执行且各自拥有独立错误边界的任务时非常有用。

回调函数的结果传递机制

在Promise链中，数据的流动依赖于每个回调函数主动返回值。如果回调中没有明确返回值，下游将无法获取任何数据。

var p = new Promise(function(resolve, reject) {
    resolve("hello world");
});

p.then(function(str) {}) // 没有 return
 .then(function(data) {
     alert(data); // undefined
 });

在上面的示例中，第二个alert不会显示内容。这是因为前一个then()回调未返回任何值。Promise规范要求回调返回数据（原始值或另一个Promise），以便将其传递给下一个环节。

转换数据的正确方式

为了实现数据转换，必须在回调中返回计算后的值：

var feetToMetres = function(ft) { 
    return ft * 0.3048; 
};

var p = new Promise(/*...*/);

p.then(feetToMetres)
 .then(function(metres) {
     alert(metres);
 });

异常的局部性与向上捕获

Promise的错误处理遵循严格的层级规则：**只有同一层级的错误处理函数（onRejected）才能捕获本层的异常**，或者由后续的catch处理。不同层级的错误处理不能互相替代。

层级捕获演示

// 场景 A：跨层捕获
new Promise(function(resolve, reject) {
    resolve("hello world");
}).then(
    function(str) {
        throw new Error("uh oh");
    },
    undefined
).then(
    undefined,
    function(error) {
        // 这里可以捕获到 "uh oh"，因为它是上一级生成的错误
        console.log(error.message); 
    }
);

// 场景 B：同级捕获失败
new Promise(function(resolve, reject) {
    resolve("hello world");
}).then(
    function(str) {
        throw new Error("uh oh");
    },
    function(error) {
        // 这个错误处理器永远不会被执行
        console.log("Error caught here");
    }
);

关键区别：在场景B中，str的处理函数和error的处理函数属于同一个.then(ON_FULFILLED, ON_REJECTED)调用。由于初始Promise是成功的，所以只有str函数运行并抛出错误。该错误发生在已解决的分支中，无法被同级别的error处理函数捕获（因为它只处理初始Promise被reject的情况）。

错误的可恢复性

Promise的状态转换具有幂等性和单向性。一旦Promise被拒绝（Rejected），进入错误处理逻辑后，如果不重新抛出错误，Promises会自动将其视为“已修复”，并将其转换为已解决（Resolved）状态，继续向下游传递。

var p = new Promise(function(resolve, reject) {
    reject(new Error("pebkac"));
});

p.then(
    undefined,
    function(error) { 
        // 处理了错误，但没有 rethrow
    } 
).then(
    function(str) {
        alert("I am saved!"); // 将会弹出此警告
    },
    function(error) {
        alert("Bad computer!");
    }
);

结论：如果在错误处理回调中未引发新的异常，Promise链条将继续作为成功流运行。这使得我们可以在特定节点进行“优雅降级”或尝试备选方案。

通过嵌套实现暂停与依赖注入

虽然.then()用于链式连接，但我们也可以在其中一个步骤中引入外部依赖，使其暂停当前的流程，直到另一个操作完成。这在需要前置条件检查（如登录验证、权限确认）时非常有效。

p.then(function(str) {
    if (!loggedIn) {
        // 暂停当前流程，转而等待新的 Promise
        return new Promise((resolve, reject) => {
            simulateLogin().then(() => resolve());
        });
    }
    // 如果已经登录，立即继续
}).then(function() {
    alert("Done with all operations.");
});

注意：在这种情况下，必须返回新创建的Promise。如果不返回，then()会认为当前步骤已经完成并直接触发下一个then()，导致在未登录状态下提前结束流程。

强制执行异步延迟（Microtask Queue）

无论Promise的状态变更多么迅速，.then()中的所有回调都保证会被推迟到下一次微任务（microtask）队列中执行，绝不会同步立即执行。这是为了保持浏览器UI渲染线程不被阻塞，并确保状态的一致性。

function runme() {
    var i = 0;
    new Promise(function(resolve) {
        resolve();
    }).then(function() {
        i += 2;
    });
    
    alert(i); // 输出 0，而不是 2
}

原因：即使resolve()被同步调用，then()回调也会被放入事件循环的微任务队列中。因此，alert(i)会在i更新之前执行。这是JavaScript单线程模型和Event Loop的核心机制之一。