Promise

Promise 是 JavaScript 中用于表示一个异步操作最终完成(或失败)及其结果值的对象。

它的出现只有一个核心目的:把异步操作的"结果"当作一个值来传递和处理,从而解决传统回调函数嵌套带来的回调地狱(Callback Hell)问题。

回调地狱的典型形态:每一步异步都依赖上一步的结果,代码不断向右/向内缩进,错误处理被重复书写无数遍,根本无法维护。

// ❌ 回调地狱:层层嵌套,错误各自处理,难以阅读与复用
fs.readFile("./a.txt", "utf-8", (err, data1) => {
    if (err) throw err;
    fs.readFile("./b.txt", "utf-8", (err, data2) => {
        if (err) throw err;
        fs.readFile("./c.txt", "utf-8", (err, data3) => {
            if (err) throw err;
            console.log(data1 + data2 + data3);
        });
    });
});
// ✅ Promise + async/await:扁平化书写,错误一处统一处理
async function main() {
    const data1 = await mineReadFile("./a.txt");
    const data2 = await mineReadFile("./b.txt");
    const data3 = await mineReadFile("./c.txt");
    console.log(data1 + data2 + data3);
}

main().catch(console.error);

ECMAScript 2015 (ES6)

1. 为什么需要 Promise

在没有 Promise 之前,异步操作只能通过回调函数完成:把”接下来要做的事”作为参数传给异步 API,由它在合适的时机回调。

这种方式有几个致命缺陷:

缺陷 说明
回调地狱 多个异步存在前后依赖时层层嵌套,代码横向膨胀,可读性极差
错误处理重复 每一层都要写一遍 if (err),稍有遗漏就会静默失败
控制流孱弱 想实现”全部完成”、”谁先完成”这类并发控制,需要手写计数器,极易出错
信任问题 回调可能被调用 0 次、1 次、甚至多次,被调用的时机也不受控
无法返回值 异步函数里 return 拿不到结果,只能层层往外传回调

Promise 把这些痛点一次性解决:它用一个对象代理未来才会拿到的结果,让你可以链式调用、统一捕获错误、自由组合并发。

2. Promise 的三种状态

Promise 实例内部维护一个状态(PromiseState),它只有三种取值。

pending

等待态(进行中)

实例刚被创建时的初始状态,此时异步操作尚未结束,结果值还是 undefined。

fulfilled

成功态(已完成)

异步操作成功完成,由执行器中的 resolve(value) 触发,结果值被固定下来。

rejected

失败态(已拒绝)

异步操作失败,由执行器中的 reject(reason) 或执行器中抛出的异常触发。

状态不可逆,且只能改变一次

一个 Promise 一旦从 pending 变为 fulfilled 或 rejected,就永远不会再变:

  • 不能从 fulfilled 变回 pending
  • 不能从 rejected 变成 pending 或 fulfilled

因此下面的代码中,第二行的 reject 和第三行的 throw 都完全无效——第一行执行完,状态就已经落定了。

let p = new Promise((resolve, reject) => {
    resolve("ok");      // pending  => fulfilled
    reject("error");    // ❌ 无效,状态已锁定
    throw "error";      // ❌ 无效,状态已锁定
});

console.log(p);         // Promise {<fulfilled>: "ok"}

3. Promise 的基本使用

3.1 创建 Promise

Promise 是一个构造函数,接收一个执行器函数(executor)作为参数。

执行器是同步立即执行的

new Promise(fn) 时,fn 会被立刻同步调用,它内部的 console.log 会排在后续同步代码之前。

// 执行器立即执行
let p = new Promise((resolve, reject) => {
    console.log(111);
});
console.log(222);

// 输出顺序:111 → 222

这一点常被误解为”Promise 让代码变异步了”。实际上执行器同步执行,只有它注册的 then 回调才是异步(微任务)执行的。

const p = new Promise((resolve, reject) => {
    // 这里写异步操作
    setTimeout(() => {
        const ok = Math.random() > 0.5;
        if (ok) {
            resolve("成功了");   // pending => fulfilled
        } else {
            reject("失败了");    // pending => rejected
        }
    }, 1000);
});

p.then(
    value  => console.log("成功:" + value),
    reason => console.log("失败:" + reason)
);

3.2 then 方法

then 接收两个可选参数:成功回调和失败回调,二者都只会有一个被调用,且只被调用一次。

p.then(
    value  => { /* fulfilled 时执行 */ },
    reason => { /* rejected 时执行 */ }
);

// 只关心成功
p.then(value => console.log(value));

// 只关心失败(等价于 p.then(null, reason => {}))
p.then(null, reason => console.error(reason));

then 注册的回调不会被同步执行,而是进入微任务队列,等当前同步代码全部跑完才开始执行。

console.log("start");

Promise.resolve().then(() => console.log("promise"));

console.log("end");

// 输出顺序:start → end → promise

同一个 Promise 可以被多次 then

状态确定后,所有注册过的回调都会被调用,且拿到的是同一个结果值。

let p = new Promise((resolve, reject) => {
    resolve("ok");
});

p.then(value => console.log(value));   // ok
p.then(value => console.log(value));   // ok

3.3 catch 方法

catch(onRejected) 是 then(null, onRejected) 的语法糖,专门用于处理失败。

p.then(value => console.log(value))
 .catch(reason => console.error(reason));

3.4 finally 方法

finally 的回调无论成功失败都会执行,适合做收尾工作(关闭 loading、释放资源)。它接收不到结果值,也不会改变已经确定的结果。

p.then(value => console.log(value))
 .catch(reason => console.error(reason))
 .finally(() => console.log("无论如何都会执行"));

4. 封装 fs 模块

把 Node.js 里基于回调的 fs.readFile 包装成返回 Promise 的函数——这是 Promise 最经典的应用之一。

const fs = require("fs");

function get(path) {
    return new Promise((resolve, reject) => {
        fs.readFile(path, "utf-8", (err, data) => {
            if (err) {
                reject(err);
                return;             // 记得 return,避免失败后又 resolve
            }
            resolve(data);
        });
    });
}

get("./content.txt").then(
    value  => console.log(value.toString()),
    reason => console.log(reason)
);

更简单的做法:util.promisify

Node.js 内置的 util.promisify 可以把任何 错误优先(error-first)回调风格的函数一次性转成返回 Promise 的函数,无需手写包装。

const util = require("util");
const fs = require("fs");

let get = util.promisify(fs.readFile);

get("./content.txt").then(value => {
    console.log(value.toString());
});

只要是形如 fn(args..., (err, result) => {}) 的 API,都可以用 util.promisify 转换。

5. 封装 AJAX

把浏览器原生 XMLHttpRequest 包装成返回 Promise 的函数。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        function send(url) {
            return new Promise((resolve, reject) => {
                const xhr = new XMLHttpRequest();

                xhr.open("GET", url);
                xhr.send();
                xhr.addEventListener("readystatechange", () => {
                    if (xhr.readyState === 4) {
                        if (xhr.status >= 200 && xhr.status < 300) {
                            resolve(xhr.response);
                        } else {
                            reject(xhr.status);
                        }
                    }
                });
            });
        }

        send("http://localhost:8030/serve").then(
            value  => console.log(value),
            reason => console.log(reason)
        );
    </script>
</body>
</html>

别忘了错误处理

xhr 的网络层错误会触发 onerror,上面的例子没有监听。生产环境中建议补上:

xhr.onerror = () => reject(new Error("网络异常"));

现代浏览器中,fetch 本身就返回 Promise,是更推荐的选择。

6. Promise 的静态方法

6.1 方法速查表

方法 作用 成功条件 失败条件
Promise.resolve(v) 快速得到一个 Promise 由参数决定 参数是失败 Promise 时为失败
Promise.reject(r) 快速得到一个失败 Promise — 永远失败
Promise.all(arr) 并发执行,全部成功才算成功 全部 fulfilled 任意一个 rejected
Promise.race(arr) 赛跑,取最先改变状态的结果 最先 fulfilled 最先 rejected
Promise.allSettled(arr) 等待全部结束,永不失败 总是成功,返回结果数组 —
Promise.any(arr) 取最先成功的那个 任意一个 fulfilled 全部 rejected

6.2 Promise.resolve

传入的参数是非 Promise 的值(普通值或普通对象),返回的结果就是成功的 Promise 对象,其值为该参数。

传入的参数是 Promise 对象,则参数的结果决定了 resolve 的结果。

let p1 = Promise.resolve(5222);

console.log(p1);   // Promise {<fulfilled>: 5222}

// 传入 Promise,结果跟随该 Promise
let p2 = Promise.resolve(Promise.reject("boom"));

console.log(p2);   // Promise {<rejected>: "boom"}

6.3 Promise.reject

返回一个失败的 Promise 对象。

let p2 = Promise.reject("sdalds");

console.log(p2);   // Promise {<rejected>: "sdalds"}

务必处理 reject

Promise.reject 产生的失败如果没有被 catch 处理,会在控制台抛出 UnhandledPromiseRejection 警告(Node.js 中甚至会直接终止进程)。任何 Promise 链的末尾都建议加上 catch。

6.4 Promise.all

接收一个包含 n 个 Promise 的数组,返回一个新的 Promise:只有所有 Promise 都成功才成功,返回值是各结果按原顺序组成的数组;只要有一个失败就整体失败。

const pro1 = new Promise((resolve, reject) => { resolve("OK"); });
const pro2 = new Promise((resolve, reject) => { resolve("OK"); });
const pro3 = new Promise((resolve, reject) => { resolve("OK"); });

let res = Promise.all([pro1, pro2, pro3]);

console.log(res);   // Promise {<fulfilled>: ["OK", "OK", "OK"]}

快速失败(fail fast)

Promise.all 是并行执行的,但只要其中一个 reject,整个 all 立刻 reject,其余 Promise 的结果会被丢弃(虽然它们的异步操作仍在继续)。

如果你希望”无论成败都等全部完成”,请用 Promise.allSettled。

6.5 Promise.race

返回一个新的 Promise,结果是第一个改变状态的 Promise 的结果(无论成功还是失败)。

Promise.all vs Promise.race

  • all:等待全部,全部成功才成功——适用于”多个依赖必须都拿到”的场景。
  • race:只取最快,谁先出结果就用谁——适用于”超时控制”这类场景。
// 用 race 实现超时控制:5 秒内没拿到结果就判定失败
function timeout(promise, ms) {
    let timer = new Promise((resolve, reject) => {
        setTimeout(() => reject(new Error("请求超时")), ms);
    });
    return Promise.race([promise, timer]);
}

timeout(fetch("/api/data"), 5000)
    .then(res => res.json())
    .catch(err => console.error(err.message));

6.6 Promise.allSettled

等待所有 Promise 都结束(不管成功失败),永远不会失败。返回值是每个 Promise 的结果对象数组,status 为 fulfilled 或 rejected。

Promise.allSettled([
    Promise.resolve(1),
    Promise.reject("err")
]).then(results => {
    console.log(results);
    // [
    //   { status: "fulfilled", value: 1 },
    //   { status: "rejected",  reason: "err" }
    // ]
});

6.7 Promise.any

取最先成功的那个 Promise 的结果;只有当全部都失败时才失败,失败原因是 AggregateError。

Promise.any([
    Promise.reject("A 失败"),
    Promise.resolve("B 成功"),
    Promise.resolve("C 成功")
]).then(value => console.log(value));   // B 成功

7. Promise 的关键问题

7.1 如何改变 Promise 的状态

改变状态一共有三种途径:

let p = new Promise((resolve, reject) => {
    // 1. pending => fulfilled
    resolve("ok");
    // 2. pending => rejected
    reject("error");
    // 3. pending => rejected(执行器中抛出的异常也会让 Promise 失败)
    throw "error";
});

console.log(p);

throw 也会被捕获

执行器中 throw 出的异常会被 new Promise 内部用 try...catch 捕获,并自动转为失败状态——这正是自定义封装时必须处理的地方。

注意:如果状态已经确定(比如先调用了 resolve),后续再 throw 就不会再改变状态了。

7.2 多次回调都会被调用

状态改变后,注册的所有回调都会被依次调用。

let p = new Promise((resolve, reject) => {
    resolve("ok");
});

p.then(value => {
    console.log(value);
});

p.then(value => {
    alert("1");
});

7.3 then 的返回结果由回调函数决定

then 方法本身总是返回一个全新的 Promise,这个新 Promise 的状态和值,由指定的回调函数的执行结果决定:

抛出异常

回调中 throw 或运行时出错 ⇒ 新 Promise 失败,值为抛出的异常。

返回非 Promise

回调返回一个普通值 ⇒ 新 Promise 成功,值为该返回值。

返回 Promise

回调返回一个 Promise ⇒ 新 Promise 的状态和结果完全由这个返回的 Promise 决定。

没有返回

回调没有返回值(即 undefined)⇒ 新 Promise 成功,值为 undefined。

let p = new Promise((resolve, reject) => {
    resolve("ok");
});

p.then(value => {
    console.log(1);
    // 1. 抛出错误        => 新 Promise 失败,值为 "错误"
    throw "错误";
    // 2. 返回普通值      => 新 Promise 成功,值为 "sdad"
    return "sdad";
    // 3. 返回 Promise    => 新 Promise 的结果就是 then 返回的这个 Promise 的结果
    return new Promise((resolve, reject) => { resolve("ok"); });
}, reason => {
    console.log(2);
});

这正是链式调用的根基

因为 then 永远返回一个新 Promise,所以可以无限 .then() 下去。每一次的结果都会作为下一次的输入,形成一条清晰的数据管道:

new Promise(resolve => resolve(1))
    .then(v => v + 1)          // 2
    .then(v => v * 10)         // 20
    .then(v => Promise.resolve(v + 5))  // 25,跟随返回的 Promise
    .then(v => console.log(v));         // 25

7.4 异常穿透

当使用 then 的链式调用时,可以在最后用 catch 统一指定失败的回调。前面任何一步出现的异常(包括没有写失败回调的 then),都会一路向下穿透,被最后的 catch 捕获。

let p = new Promise((resolve, reject) => {
    resolve("ok");
});

p.then(value => {
    console.log(1);
}, reason => {
    console.log(2);
}).then(value => {
    console.log(value);
}).then(value => {
    console.log(value);
}).catch(reason => {
    console.log(reason);   // 前面任意环节出错,都会落到这里
});

为什么能穿透

因为当某个 then 没有指定失败回调时,会用默认的失败回调 reason => { throw reason; } 把错误原样再抛出去,于是错误就被下一个 Promise 继承,一直传到遇到 catch 为止。

7.5 中断 Promise 链

想在某个环节中断后续的链式调用,唯一的方法是返回一个 pending 状态的 Promise——因为后续 then 的回调需要在这个 Promise 状态改变后才会执行,而它永远不会改变。

p.then(value => {
    console.log(1);
    // 唯一方法:返回一个 pending 状态的 Promise
    return new Promise(() => {});
}, reason => {
    console.log(2);
}).then(value => {
    console.log(value);   // ❌ 不会执行
}).then(value => {
    console.log(value);   // ❌ 不会执行
}).catch(reason => {
    console.log(reason);  // ❌ 不会执行
});

8. 手写实现 Promise

下面是一个遵循 Promise/A+ 规范核心思想的自定义封装,完整覆盖状态管理、异步回调、链式调用以及各个静态方法。

/* 封装为一个类 */
class Promise {
    constructor(executor) {
        // 1. 初始状态
        this.PromiseState = 'pending';
        // 2. 初始结果
        this.PromiseResult = null;
        // 3. 保存 pending 状态下注册的回调
        this.callbacks = [];

        /* 保存实例对象的 this 值 */
        const self = this;

        function resolve(data) {
            // 状态只能改变一次
            if (self.PromiseState !== 'pending') return;
            self.PromiseState = 'fulfilled';
            self.PromiseResult = data;
            // 异步执行已保存的成功回调
            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onResolved(data);
                });
            });
        }

        function reject(data) {
            if (self.PromiseState !== 'pending') return;
            self.PromiseState = 'rejected';
            self.PromiseResult = data;
            // 异步执行已保存的失败回调
            setTimeout(() => {
                self.callbacks.forEach(item => {
                    item.onRejected(data);
                });
            });
        }

        // 同步调用执行器函数,捕获其中抛出的异常
        try {
            executor(resolve, reject);
        } catch (e) {
            reject(e);
        }
    }

    then(onResolved, onRejected) {
        const self = this;

        // 异常穿透:没有传失败回调时,默认把错误继续往下抛
        if (typeof onRejected !== 'function') {
            onRejected = reason => { throw reason; };
        }
        // 值穿透:没有传成功回调时,默认把结果继续往下传
        if (typeof onResolved !== 'function') {
            onResolved = value => value;
        }

        return new Promise((resolve, reject) => {
            function callback(type) {
                try {
                    let result = type(self.PromiseResult);
                    if (result instanceof Promise) {
                        // 返回 Promise:结果由它决定
                        result.then(v => resolve(v), r => reject(r));
                    } else {
                        // 返回普通值:直接成功
                        resolve(result);
                    }
                } catch (e) {
                    // 抛出异常:直接失败
                    reject(e);
                }
            }

            if (this.PromiseState === 'fulfilled') {
                setTimeout(() => callback(onResolved));
            }
            if (this.PromiseState === 'rejected') {
                setTimeout(() => callback(onRejected));
            }
            if (this.PromiseState === 'pending') {
                // 状态未定,先把回调保存起来,等状态改变时再执行
                this.callbacks.push({
                    onResolved: function () { callback(onResolved); },
                    onRejected: function () { callback(onRejected); }
                });
            }
        });
    }

    catch(onRejected) {
        return this.then(undefined, onRejected);
    }

    // 静态方法 resolve
    static resolve(value) {
        return new Promise((resolve, reject) => {
            if (value instanceof Promise) {
                value.then(v => resolve(v), r => reject(r));
            } else {
                resolve(value);
            }
        });
    }

    // 静态方法 reject
    static reject(reason) {
        return new Promise((resolve, reject) => {
            reject(reason);
        });
    }

    // 静态方法 all:全部成功才成功
    static all(promises) {
        return new Promise((resolve, reject) => {
            let count = 0;
            let arr = [];
            for (let i = 0; i < promises.length; i++) {
                promises[i].then(v => {
                    count++;
                    arr[i] = v;              // 结果按原顺序存放
                    if (count === promises.length) {
                        resolve(arr);        // 全部成功,返回数组
                    }
                }, r => {
                    reject(r);               // 一个失败,整体失败
                });
            }
        });
    }

    // 静态方法 race:取最先改变状态的结果
    static race(promises) {
        return new Promise((resolve, reject) => {
            for (let i = 0; i < promises.length; i++) {
                promises[i].then(v => resolve(v), r => reject(r));
            }
        });
    }
}

实现要点回顾

  • 状态锁:resolve/reject 里第一件事就是判断当前是否为 pending,这保证了状态只改变一次。
  • 回调异步执行:用 setTimeout 包裹,模拟微任务的异步语义,确保 then 回调不会同步调用。
  • 回调缓存:pending 时把回调存进 callbacks 数组,状态改变后再统一取出执行。
  • 异常捕获:执行器和每个回调都用 try...catch 包裹,异常一律转为失败。
  • then 返回新 Promise:.then 内部 return new Promise(...),这是链式调用与异常穿透的基础。
  • 原生 Promise 用的是微任务:这里用 setTimeout(宏任务)只是为了模拟,规范实现应使用 queueMicrotask 或 MutationObserver。

9. async 与 await

async/await 是 ES2017 引入的语法糖,它建立在 Promise 之上,让你用写同步代码的方式写异步代码,彻底消灭了 .then 的嵌套。

9.1 async 函数

被 async 修饰的函数,其返回值一定是一个 Promise 对象:

  • 返回一个非 Promise 值 ⇒ 结果为成功的 Promise,值为该返回值
  • 返回一个 Promise ⇒ 结果由这个 Promise 决定
  • 抛出异常 ⇒ 结果为失败的 Promise,值为抛出的异常
async function main() {
    return new Promise((resolve, reject) => {
        // resolve("OK");
        reject("ERROR");
    });
    throw "DZ";   // 注意:上面已经 return 了,这行不会执行
}

let result = main();

console.log(result);   // Promise {<rejected>: "ERROR"}

也可以直接用 await 接住异常

async 函数的返回值是 Promise,所以用 .catch() 或 await 配合 try...catch 都能处理失败。

9.2 await 表达式

await 必须写在 async 函数中,但 async 函数中可以没有 await。

await 右侧一般是 Promise 对象,得到的是它成功的值;如果右侧是普通值,则直接返回该值本身。

如果 await 的 Promise 失败了,就会抛出异常,需要通过 try...catch 捕获处理。

async function main() {
    let p = new Promise((resolve, reject) => {
        // resolve("OK");
        reject("ERROR");
    });

    /* let res = await p;
       console.log(res);

       let res2 = await 20;   // 非 Promise,直接得到 20
       console.log(res2); */

    try {
        let res = await p;
    } catch (e) {
        console.log(e);   // ERROR
    }
}

await 会阻塞(仅阻塞 async 函数内部)

await 会暂停当前 async 函数的执行,等待 Promise 落定后再继续。但它不会阻塞主线程,外面的同步代码照常运行。这也是它比同步阻塞写法优越的原因。

9.3 并发还是串行

await 默认是串行的,前一个完成才会执行下一个。如果需要并发,请配合 Promise.all。

// ⚠️ 串行:总共耗时 ≈ 三者之和
const a = await task1();
const b = await task2();
const c = await task3();

// ✅ 并发:总共耗时 ≈ 最慢的那个
const [a, b, c] = await Promise.all([task1(), task2(), task3()]);

注意:不要在循环中直接 await

// ❌ 串行,n 次请求叠加耗时
for (const url of urls) {
    await fetch(url);
}

// ✅ 并发,一次性发出
await Promise.all(urls.map(url => fetch(url)));

9.4 结合案例

同一个”读取三个文件并拼接”的需求,三种写法的演进:

const fs = require("fs");
const util = require("util");
const mineReadFile = util.promisify(fs.readFile);

/* ① 回调地狱写法
fs.readFile("../res/1.html", "utf-8", (err, datastr1) => {
    if (err) throw err;
    fs.readFile("../res/2.html", "utf-8", (err, datastr2) => {
        if (err) throw err;
        fs.readFile("../res/3.html", "utf-8", (err, datastr3) => {
            if (err) throw err;
            console.log(datastr1 + "  " + datastr2 + "   " + datastr3);
        });
    });
}); */

/* ② async/await 串行写法(示例中原写法三个路径相同,实际应分别为 1/2/3.html) */
async function main() {
    let datastr1 = await mineReadFile("../res/1.html");
    let datastr2 = await mineReadFile("../res/2.html");
    let datastr3 = await mineReadFile("../res/3.html");
    console.log(datastr1 + "  " + datastr2 + "   " + datastr3);
}

main();

/* ③ 并发写法:三个文件同时读取,效率更高 */
async function mainFast() {
    const arr = await Promise.all([
        mineReadFile("../res/1.html"),
        mineReadFile("../res/2.html"),
        mineReadFile("../res/3.html")
    ]);
    console.log(arr.join("  "));
}

mainFast();

10. 实践要点

每个 Promise 链都以 catch 收尾

未被捕获的 rejection 会变成 UnhandledPromiseRejection,在 Node.js 中甚至会让进程崩溃。

注意 return 的重要性

then 回调里如果调用异步操作却**忘记 return**,外层链就等不到它,结果会丢失。

all vs allSettled 要分清

要求”缺一不可”用 all;只要全部跑完、允许部分失败用 allSettled。

用 race 做超时控制

网络请求务必加超时兜底,避免无限期挂起。

循环里别直接 await

需要并发时用 Promise.all(arr.map(...)),否则会退化成串行。

async 函数返回值永远是 Promise

即便 return 1,外面拿到的也是 Promise {<fulfilled>: 1}。


附:核心 API 一览

API 语法 说明
new Promise(executor) new Promise((resolve, reject) => {}) 创建一个 Promise,执行器同步立即执行
then p.then(onResolved, onRejected) 注册回调,返回新的 Promise
catch p.catch(onRejected) 捕获失败,等价于 then(null, onRejected)
finally p.finally(onFinally) 无论成败都会执行,接收不到结果值
resolve Promise.resolve(value) 快速得到一个 Promise,结果由参数决定
reject Promise.reject(reason) 快速得到一个失败的 Promise
all Promise.all([p1, p2, ...]) 全部成功才成功,返回结果数组
race Promise.race([p1, p2, ...]) 取最先落定的那个结果
allSettled Promise.allSettled([p1, p2, ...]) 等待全部结束,永不失败
any Promise.any([p1, p2, ...]) 取最先成功的那个,全失败才失败
async async function fn() {} 声明异步函数,返回值必为 Promise
await const v = await p 等待 Promise 结果,只能在 async 内使用

一句话总结:Promise 用”一个代表未来的值的对象”取代了层层嵌套的回调;而 async/await 又把这个对象还原成了看起来像同步的代码——两者结合,才是现代 JavaScript 异步编程的标准写法。