彻底理解Promise

最新推荐文章于 2024-10-18 18:45:22 发布
最新推荐文章于 2024-10-18 18:45:22 发布
阅读量837 收藏 9
点赞数 18
分类专栏： JavaScript高级学习 文章标签： 前端 javascript 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45730399/article/details/141263067
版权

目录

Promise基本

引入Pomise

Promise 是 JavaScript 引入的一种处理异步操作的机制，它代表一个异步操作的最终完成（或失败）及其结果值，它旨在解决异步编程中常见的问题，引入 Promise 的主要原因包括：

  • 为了解决回调地狱
    在传统的回调函数（callback）方式中，多个异步操作的回调函数嵌套在一起，形成了所谓的回调地狱或回调金字塔，使得代码变得难以阅读和维护
    doSomething(function (result) {
  doSomethingElse(result, function (newResult) {
    doAnotherThing(newResult, function (finalResult) {
      console.log(finalResult);
    });
  });
});
  • 为了有更好的错误提示：使用回调函数时，错误处理往往不够直观，尤其是当异步操作链很长时
    doSomething(function (result) {
  doSomethingElse(result, function (newResult) {
    doAnotherThing(newResult, function (finalResult) {
      console.log(finalResult);
    }, function (error) {
      console.error(error);
    });
  }, function (error) {
    console.error(error);
  });
}, function (error) {
  console.error(error);
});
  • 为了方便使用和规范

    • 第一：我们需要自己来设计回调函数、回调函数的名称、回调函数的使用等；

    • 第二：对于不同的人、不同的框架设计出来的方案是不同的，那么我们必须耐心去看别人的源码或者文档，以便可以理解这个函数到底怎么用

代码结构

  • Promise是一个类，可以翻译成 承诺、许诺 、契约

  • 当我们需要给予调用者一个承诺，待会儿我会给你回调数据时，就可以创建一个Promise的对象

  • 在通过 new创建Promise对象 时，我们需要传入一个回调函数

    • 这个回调函数会被立即执行，有两个参数为回调函数resolve、reject

    • 当我们调用resolve回调函数时，会执行实例的then方法传入的回调函数

    • 当我们调用reject回调函数时，会执行实例的catch方法传入的回调函数

    • 可链式调用then和catch

  • 代码示例如下：

    const promise = new Promise((resolve, reject) => {
  console.log("这个函数会立即执行");
  resolve("成功"); // 会执行then
  // reject("失败"); // 会执行catch
});

// promise.then((res) => {
//   console.log(res); // 成功
// });
// promise.catch((err) => {
//   console.log(err); // 失败
// });

promise
  .then((res) => {
    console.log(res); // 成功
  })
  .catch((err) => {
    console.log(err); // 失败
  });

三个状态

  • 待定（pending）: 初始状态，既没有被兑现也没有被拒绝，当执行executor中的代码时，处于该状态
  • 已兑现（fulfilled）: 意味着操作成功，执行了resolve时处于该状态
  • 已拒绝（rejected）: 意味着操作失败，执行了reject时处于该状态

注意：一旦状态被确定下来，Promise的状态会被锁死，该Promise的状态是不可更改的

const promise = new Promise((resolve, reject) => {
  console.log("这个函数会立即执行");
  resolve("成功");
  reject("失败"); // promise的状态已经确定resolve，不会执行reject
});

promise
  .then((res) => {
    console.log(res); // 成功
  })
  .catch((err) => {
    console.log(err); // catch不会执行
  });

Executor

Executor是在创建Promise时需要传入的一个回调函数，这个回调函数会被立即执行，并且传入两个参数resolve和reject，会在Executor中确定Promise状态：

  • 通过resolve，可以兑现（fulfilled）Promise的状态，我们也可以称之为已决议（resolved）
  • 通过reject，可以拒绝（reject）Promise的状态

resolve传不同值

  • 如果resolve传入一个普通的值或者没有实现then方法的对象，那么这个值会作为then回调的参数

    const promise = new Promise((resolve, reject) => {
  console.log("这个函数会立即执行");
  resolve("成功");
  // resolve(123);
  // resolve({ name: "obj" });
});
promise.then((res) => {
  console.log(res); // 打印：成功 || 123 || { name: "obj" }
});

  • 当的 resolve 方法中传入的值是一个对象并且该对象实现了 then 方法时，Promise 会将这个对象视为一个 thenable 对象（一个具有 then 方法的对象），会根据这个对象中 then 方法的执行结果来决定最终的 Promise 状态。这种行为被称为 “Promise A+ 规范” 中的 “Promise Resolution Procedure”

    • 当 Promise.resolve 遇到一个 thenable 对象时，它会自动调用这个对象的 then 方法，并且将内部生成的 resolve 和 reject 函数传递进去

    • 在 thenable 对象的 then 方法中，resolve 和 reject 这两个参数是回调函数，它们由 Promise 内部机制提供用来处理异步操作的成功或失败，相当于 Promise 本身的 resolve 和 reject 方法，能够决定当前 Promise 的最终状态

    • 当在 thenable 对象的 then 方法中使用 resolve(传不同值) 时，和外面的三种情况一致

    • 如果 thenable 对象的 then 方法抛出异常，Promise 会将捕获异常作为最终结果，状态为 rejected

    const promise1 = new Promise((resolve, reject) => {
  console.log("这个promise1Log会立即执行"); // 这个promise1Log会立即执行
  resolve({
    name: "thenable1",
    then(resolve, reject) {
      resolve("thenable1成功");
    },
  });
});
promise1.then((res) => {
  console.log(res); // thenable1成功
});

const promise2 = new Promise((resolve, reject) => {
  console.log("这个promise2Log会立即执行"); // 这个promise2Log会立即执行
  resolve({
    name: "thenable2",
    then(resolve, reject) {
      reject("thenable2失败");
    },
  });
});
promise2
  .then((res) => {
    console.log(res);
  })
  .catch((err) => {
    console.log(err); // thenable2失败
  });

const promise3 = new Promise((resolve, reject) => {
  console.log("这个promise3Log会立即执行"); // 这个promise3Log会立即执行
  resolve({
    name: "thenable3",
    then() {
      console.log("thenable3Log"); // 会执行打印：thenable3Log
    },
  });
});
promise3 // then和catch都不会执行
  .then((res) => {
    console.log(res);
  })
  .catch((err) => {
    console.log(err);
  });

const promise4 = new Promise((resolve, reject) => {
  console.log("这个promise4Log会立即执行"); // 这个promise4Log会立即执行
  resolve({
    name: "thenable4",
    then() {
      throw "thenable4抛出错误"; // promise4状态为rejected
    },
  });
});
promise4
  .then((res) => {
    console.log(res);
  })
  .catch((err) => {
    console.log(err); // thenable4抛出错误
  });

  • 如果resolve中传入的是另外一个Promise，则会返回这个新的Promise，那么这个新Promise会决定原Promise的状态

    const promise = new Promise((resolve, reject) => {
  console.log("这个promiseLog会立即执行"); // 这个promiseLog会立即执行
  resolve(
    new Promise((resolve, reject) => {
      resolve("resolvePromise");
    })
  );
});
promise.then((res) => {
  console.log(res); // resolvePromise
});
// 相当于 new Promise((resolve) => resolve("resolvePromise")).then(res => console.log(res))

Promise实例方法

then方法

then方法是Promise对象上的一个方法（实例方法），它其实是放在Promise的原型上的 Promise.prototype.then

两个参数

then方法接受两个参数：

  • fulfilled的回调函数：当状态变成fulfilled时会回调的函数
  • rejected的回调函数：当状态变成rejected时会回调的函数
const promise = new Promise((resolve, reject) => {
  console.log("这个promiseLog会立即执行"); // 这个promiseLog会立即执行
  reject('失败');
});
// promise
//   .then((res) => {
//     console.log(res);
//   })
//   .catch((err) => {
//     console.log(err); // 失败
//   });
// 等价于
promise.then(
  (res) => {
    console.log(res);
  },
  (err) => {
    console.log(err); // 失败
  }
);

多次调用

一个Promise的then方法是可以被多次调用的，都会在 Promise状态 fulfilled时被依次调用且彼此独立

let promise = new Promise((resolve, reject) => {
  setTimeout(() => resolve("结果"), 1000);
});

promise.then(result => {
  console.log("第一个 then:", result);
});
promise.then(result => {
  console.log("第二个 then:", result);
});
promise.then(result => {
  console.log("第三个 then:", result);
});
// 输出：第一个 then: 结果； 第二个 then: 结果； 第三个 then: 结果

返回值

then方法本身是有返回值的，它的返回值是一个Promise，从而可以进行链式调用

  • 但是then方法返回的Promise到底处于什么样的状态呢？

    • 当then方法中的回调函数本身在执行的时候，那么它处于pending状态

    • 当then方法中的回调函数返回一个结果时，那么它处于fulfilled状态，并且会将结果作为resolve的参数

    • 当then方法抛出一个异常时，那么它处于rejected状态

const promise = new Promise((resolve, reject) => {
  console.log("这个promiseLog会立即执行"); // 这个promiseLog会立即执行
  resolve("成功");
});
promise
  .then((res) => {
    console.log(res); // 打印：成功
    // return 123; // 这时then方法返回的promise状态是fulfilled
    throw "thenPromise失败"; // 这时then方法返回的promise状态是rejected
  })
  .then((res) => {
    console.log(res); // 123
  })
  .catch((err) => {
    console.log(err); // thenPromise失败
  });

catch方法

catch方法是Promise对象上的一个方法（实例方法），是放在Promise的原型上的 Promise.prototype.catch

多次调用

Promise的catch方法是可以被多次调用的，当Promise的状态变成reject的时候，这些回调函数都会被依次执行

const promise = new Promise((resolve, reject) => {
  console.log("这个promiseLog会立即执行"); // 这个promiseLog会立即执行
  reject("失败");
});
promise.catch((err) => {
  console.log("第一catch回调执行：" + err);
});
promise.catch((err) => {
  console.log("第二catch回调执行：" + err);
});
promise.catch((err) => {
  console.log("第三catch回调执行：" + err);
});
// 输出：第一catch回调执行：失败；第二catch回调执行：失败；第三catch回调执行：失败

返回值

catch方法也是返回一个Promise对象的，所以catch方法后可以继续调用then方法或者catch方法：如果我们希望后续继续执行catch，那么需要抛出一个异常

const promise = new Promise((resolve, reject) => {
  console.log("这个promiseLog会立即执行"); // 这个promiseLog会立即执行
  reject("失败");
});
promise
  .catch((err) => {
    throw "catchPromise失败"; // 需要执行后续的catch要抛出异常
  })
  .catch((err) => {
    console.log(err); // catchPromise失败
  });

会有报错情况：下面例子如果没有直接在 promise实例上调用catch，后面的 .then() 链式调用会将异常向下传播，最终被找到的 .catch() 捕获，即被最近的catch捕获

  • 如果不写最后的catch 或者其他形式的错误处理（比如 then 中的第二个参数），Promise 在被拒绝（rejected）后，浏览器会错误提示（unhandled promise rejection）
const promise = new Promise((resolve, reject) => {
  console.log("这个promiseLog会立即执行"); // 这个promiseLog会立即执行
  reject("失败");
});
promise
  .then((res) => {
    throw "then1Throw";
  })
  .then((res) => {
    throw "then2Throw";
  })
  .catch((err) => {
    console.log(err); // 失败
  });

finally方法

finally是在ES9（ES2018）中新增的一个特性：表示无论Promise对象无论变成fulfilled还是rejected状态，最终都会被执行，finally方法不接收参数

const promise = new Promise((resolve, reject) => {
  console.log("这个promiseLog会立即执行"); // 这个promiseLog会立即执行
  // reject('失败')
  resolve("成功");
});
promise
  .then((res) => {
    console.log(res) // 成功
  })
  .catch((err) => {
    console.log(err); // 失败
  })
  .finally(() => {
    console.log("finally"); // 成功失败都会执行打印
  });

Promise类方法

前面的then、catch、finally方法都属于Promise的实例方法，都是存放在Promise的prototype上的，后面的类方法就是直接通过Promise调用的

resolve方法

一个用于将现有的值转换为一个已成功完成（fulfilled）的 Promise 对象的方法，Promise.resolve的用法相当于new Promise，并且执行resolve操作

  • 传递值的情况和上面resolve传不同值情况一样
Promise.resolve("123").then((res) => {
  console.log(res); // 123
});
// Promise.resolve("123") 相当于 new Promise((resolve) => resolve(123))

reject方法

和Promise.resolve类似，一个用于将现有的值转换为一个已拒绝（rejected）的 Promise 对象的方法，Promise.reject的用法相当于new Promise，并且执行reject操作

  • 传入的参数无论是什么形态，都会直接作为rejected状态的参数传递到catch的
Promise.reject("123").catch((res) => {
  console.log(res); // 123
});
// Promise.reject("123") 相当于 new Promise((reject) => reject(123))

all方法

它的作用是将多个Promise包裹在一起形成一个新的Promise

  • 新的Promise状态由包裹的所有Promise共同决定

    • 必须当所有的Promise状态变成fulfilled状态时，新的Promise状态为fulfilled，并且会将所有Promise的返回值组成一个数组

    • 当有一个Promise状态为reject时，新的Promise状态为rejected，并且会将第一个reject的返回值作为catch参数

const promise1 = new Promise((resolve) => resolve("promise1"));
const promise2 = new Promise((resolve) => resolve("promise2"));
const promise3 = new Promise((resolve) => resolve("promise3"));
Promise.all([promise1, promise2, promise3]).then((res) => {
  console.log(res); // ['promise1', 'promise2', 'promise3']
});

const promise4 = new Promise((resolve) => resolve("promise4"));
const promise5 = new Promise((resolve, reject) =>
  reject("promise5Reject")
);
const promise6 = new Promise((resolve) => resolve("promise6"));
Promise.all([promise4, promise5, promise6]).catch((err) => {
  console.log(err); // promise5Reject
});

all方法有一个缺陷：当有其中一个Promise变成reject状态时，新Promise就会立即变成对应的reject状态，那么对于resolved的和处于pending状态的Promise，获取不到对应的结果

allSettlet方法

解决了all的缺陷，在ES11（ES2020）中，添加了新的API Promise.allSettled

  • 该方法会在所有的Promise都有结果时才会有最终的状态，这个新Promise的状态一定是fulfilled的

  • allSettled的结果是一个数组，数组中存放着每一个Promise的结果对应一个对象的，这个对象中包含status状态，以及对应的value值

const promise1 = new Promise((resolve) => resolve("promise1"));
const promise2 = new Promise((resolve, reject) =>
  reject("promise2Reject")
);
const promise3 = new Promise((resolve) => resolve("promise3"));
Promise.allSettled([promise1, promise2, promise3])
  .then((res) => {
    console.log(res);
  });

在这里插入图片描述

race方法

多个Promise时，当有一个Promise有了最终状态，希望这个状态是最新Promise的状态，那么可以使用race方法

  • race是竞技、竞赛的意思，表示多个Promise相互竞争，谁先有结果，那么就使用谁的结果
const promise1 = new Promise(() => {});
const promise2 = new Promise((resolve, reject) =>
  reject("promise2Reject")
);
Promise.race([promise1, promise2])
  .then((res) => {
    console.log(res); // 不会执行
  })
  .catch((err) => {
    console.log(err); // promise2Reject
  });

any方法

any方法是ES12中新增的方法，和race方法是类似的

  • any方法会等到一个fulfilled状态，才决定新Promise为fulfilled状态

  • 如果所有的Promise都是rejected的，会等到所有的Promise变成rejected状态时catch回调报错：AggregateError: All promises were rejected

const promise1 = new Promise((resolve, reject) =>
  reject("promise1Reject")
);
const promise2 = new Promise((resolve) => resolve("promise2"));
Promise.any([promise1, promise2])
  .then((res) => {
    console.log(res); // promise2
  })
  .catch((err) => {
    console.log(err); 
  });

手写Promise

具体待后面练习后补充

你会发光哎u
关注
专栏目录
es5如何实现promise_彻底理解Promise对象——用es5语法实现一个自己的Promise(上篇)...
weixin_39987138的博客
12-22 396
众所周知javascript语言的一大特色就是异步，这既是它的优点，同时在某些情况下也带来了一些的问题。最大的问题之一，就是异步操作过多的时候，代码内会充斥着众多回调函数，乃至形成回调金字塔。为了解决回调函数带来的问题，Promise作为一种更优雅的异步解决方案被提出，最初只是一种实现接口规范，而到了es6，则是在语言层面就原生支持了Promise对象。最初接触Promise的时候，我觉得它是比较...
让你彻底掌握es6 Promise的八段代码
08-29
Promise对象可以理解为一次执行的异步操作，使用promise对象之后可以使用一种链式调用的方式来组织代码；让代码更加的直观，下面这篇文章主要跟大家分享了让大家彻底掌握es6 Promise的八段代码，需要的朋友可以参考下。
彻底理解promise
benben0729的专栏
02-15 302
原文：https://www.liaoxuefeng.com/wiki/001434446689867b27157e896e74d51a89c25cc8b43bdb3000/0014345008539155e93fc16046d4bb7854943814c4f9dc2000 在JavaScript的世界中，所有代码都是单线程执行的。 由于这个“缺陷”，导致JavaScript的所有网络操作，浏览器...
手撕代码彻底理解Promise
到得还来别无事，庐山烟雨浙江潮。
11-10 960
手写Promise实现原理，理解其基本使用和使用场景。
彻底理解Promise和async/await
weixin_49035434的博客
05-02 1813
promise
【异步系列三】10道 Promise 面试题彻底理解 Promise 异步执行顺序
二三的博客
09-23 7345
上一篇文章详细说明了关于 Promise 的概念以及执行顺序，Promise 作为 JavaScript 中的关键特性，无论是在日常工作中还是面试中，我们都必须掌握它。前段时间在网上看到了一些关于 Promise 的面试题，质量很好，在这里整理到下面，并加上我一些自己的见解，欢迎斧正！
这一次，彻底理解Promise
qq_52569656的博客
02-20 107
本文主要介绍的Es6中的Promsie对象，通过js构造函数实现Promise常用的方法以此来加深对Promise的理解。
通过一个实际案例彻底理解 promise
杏子
07-19 1281
从一个实际案例彻底理解 promise前言案例案例分析通过 Promise 对案例进行优化总结 前言 JavaScrip 是单线程，前端在大部分情况下写出来的 JS 代码都是同步执行。偶尔会通过回调函数达到异步执行的目的。后来有了 promise 对象解决异步问题，被纳入到 ES6 标准中。 但是很多人都不理解 promise，或者一知半解，感觉懂又好像不懂，最主要的是在实际项目中用得少，不能够学...
这一次，彻底理解Promise源码思想
嘿嘿
07-22 156
目录 实现一个简单的Promise函子 同时调用同一个Promise函子 增加reject回调函数 增加Promise状态 Maybe函子优化 总结 关于Promise的源码实现，网上有太多答案，我也看过很多资料，但都不是很明白。直到有一天我学完函数式编程之函子的概念，才对Promise源码有了更深刻的认识。今天，就让我们来重新认识一下Promise。 我们知道，Promise的诞生是为了解决“回调地狱”的问题，它用同步链式的方式去解决异步的嵌套回调。 啥？同步链式？这不就是我们上一节.
【转】彻底理解Promise对象——用es5语法实现一个自己的Promise(上篇)
carcarrot的博客
09-21 346
众所周知javascript语言的一大特色就是异步，这既是它的优点，同时在某些情况下也带来了一些的问题。最大的问题之一，就是异步操作过多的时候，代码内会充斥着众多回调函数，乃至形成回调金字塔。为了解决回调函数带来的问题，Promise作为一种更优雅的异步解决方案被提出，最初只是一种实现接口规范，而到了es6，则是在语言层面就原生支持了Promise对象。 最初接触Promise的时候，我觉得它是比较抽象并且令人困惑的，相信很多人也有同样的感觉。但是在后来的熟悉过程中，我慢慢体会到了它的优雅，并开始思考Pr
30分钟，让你彻底明白Promise原理1
08-03
在本文中，我们将深入理解Promise的原理，通过一个简单的实现来探讨其核心机制。 首先，Promise的核心在于它的状态管理。一个Promise实例有三种状态：pending（进行中）、fulfilled（已完成）和rejected（已失败）...
Promise的理解与使用
qq_53061847的博客
07-12 2082
2.使用 promise 封装 ajax 异步请求 3.fs模块使用Promise 4.异常穿透 5. 2、为什么要用Promise? Ⅰ-指定回调函数的方式更加灵活 Ⅱ-支持链式调用, 可以解决回调地狱问题 1、什么是回调地狱 2、回调地狱的缺点? 3、解决方案? 4、终极解决方案? 3、Promise中的常用 API 概述 Ⅰ- Promise 构造函数: Promise (excutor) {} Ⅱ-Promise.prototype.then 方法: (onResolv
Promise微任务例子分析--彻底理解（有基础的再看）
wyksxxl的博客
09-26 563
console.log('*********************************************************') setTimeout(() => { console.log("主要是看宏任务什么时候执行") }, 0); var p1 = new Promise((res, rej)...
06_实现watch
qq_53109172的博客
10-16 1091
watch 本质上就是监听一个响应式数据，这个响应式数据发生变化的时候，进行通知并触发相应的回调函数。
004-按照指定功能模块名称分组
xiaogang1226的博客
10-16 386
需要把一个功能模块的几个功能点放在同一个文档目录下，这几个功能点分布在不同的 Controller。需要把他们单独分组，方便前端对接。在@ApiOperation 里面增加属性 tags 赋值。
前端开发攻略---8种方法实现在浏览器中跨页面通信
nibabaoo的博客
10-15 1254
浏览器实现跨标签页通信的多种方式
前端地图数据开发
shuxiaoxii的博客
10-13 353
基于Turf.js教你快速实现地理围栏的合并拆分。turf js 地理空间分析库，处理各种地图算法。如何拆分一个乡镇或区的地图。获取市级的行政区域划分。直接导入地图的json。高德地图查看市级区域。js实现地图区域合并。
计算机毕业设计 | SSM 校园线上订餐系统(附源码)
说书客
10-14 1123
本系统基于SSM实现了餐馆点餐系统。项目功能（用户点餐子系统）：登录注册，选座，商品购买，我的订单等。（后台管理子系统）：用户管理，餐桌管理，菜品管理，菜系管理，订单管理等
Java根据word 模板，生成自定义内容的word 文件
最新发布
missgrass的博客
10-18 686
主要是项目中需要定制化一个word，也就是有一部分是固定的，就是有一个底子，框架，里面的内容是需要填充的。然后填充的内容很多，包括文本框、图片、文本、前端传过来的富文本、表格的设计。我最开始用的是EasyPoi的方法进行导入的，也就是网上比较常见的下面这样的方法进行填充word模版，如果你只比较简单的数据，那使用EasyPoi就够了。但是我涉及到了富文本的转换，就是我要把富文本渲染成docx支持的格式，所以我换了种方法。我这里是在静态资源里的模版，你也可以读取自己的其他目录下的文件，主要是只要是。
promise 面试
08-18
题目是什么以及为什么在面试中需要掌握Promise？ 在面试中，关于Promise的面试题目可以涉及Promise的基本概念、使用方法和原理等方面的内容。例如，可以要求解析一段Promise的代码，或者要求描述Promise的执行顺序和特性等。通过这些面试题目，面试官可以了解面试者对Promise的理解程度和应用能力，进而评估其在异步编程方面的能力和经验。 面试中需要掌握Promise的原因主要有以下几点： 1. 异步编程是现代前端开发中非常重要的一部分，Promise是一种用于处理异步操作的机制，能够更好地处理回调地狱问题和提高代码的可读性。 2. Promise是JavaScript中的关键特性之一，在使用现代前端框架如React和Angular时，几乎无法避免使用Promise。因此，掌握Promise能够更好地理解和应用这些框架。 3. Promise是面试中常见的考点之一，掌握Promise能够更好地准备面试，展现自己的技术能力和经验。 综上所述，掌握Promise对于面试来说是非常重要的，它能够展示你对异步编程的理解和应用能力，并且能够提升你在面试中的竞争力。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [【异步系列三】10道 Promise 面试题彻底理解 Promise 异步执行顺序](https://blog.csdn.net/qq_41131745/article/details/127004662)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* [10 个 JavaScript Promise 的面试题](https://blog.csdn.net/snsHL9db69ccu1aIKl9r/article/details/125454133)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值