Promise 中的异步错误 怎么捕获

在Promise中同步产生的错误,用catch捕获就可以了,如下所示:

    getHttpData() {
      return new Promise((resolve, reject) => {
        let obj = {
          status: 200,
        };
        if (obj.abc.status === 200) {
          resolve(200);
        } else {
          reject(404);
        }
      });
    },

    test() {
      this.getHttpData()
        .then((res) => {
          console.log("liubbc res: ", res);
        })
        .catch((err) => {
          console.log("liubbc err: ", err);
        });
    },

在obj.abc.status这里会出现引用错误,因为是同步错误,可以被catch捕获。我们在看下,在Promise中异步产生的错误能否被catch捕获?代码如下:

    getHttpData() {
      return new Promise((resolve, reject) => {
        setTimeout(() => {
          let obj = {
            status: 200,
          };
          if (obj.abc.status === 200) {
            resolve(200);
          } else {
            reject(404);
          }
        }, 2000);
      });
    },

    test() {
      this.getHttpData()
        .then((res) => {
          console.log("liubbc res: ", res);
        })
        .catch((err) => {
          console.log("liubbc err: ", err);
        });
    },

大家可以执行一下,catch并没有捕获到引用错误。原因就是错误是异步的,catch捕获不到。

怎么让catch能捕获到呢?用对异步代码加try  catch ,然后把错误reject出去,这样就可以捕获到异步代码里面的错误了。代码如下:

    getHttpData() {
      return new Promise((resolve, reject) => {
        setTimeout(() => {
          try {
            let obj = {
              status: 200,
            };
            if (obj.abc.status === 200) {
              resolve(200);
            } else {
              reject(404);
            }
          } catch (error) {
            reject(error);
          }
        }, 2000);
      });
    },

    test() {
      this.getHttpData()
        .then((res) => {
          console.log("liubbc res: ", res);
        })
        .catch((err) => {
          console.log("liubbc err: ", err);
        });

当然也可以写成async await 形式,代码如下:

    getHttpData() {
      return new Promise((resolve, reject) => {
        setTimeout(() => {
          try {
            let obj = {
              status: 200,
            };
            if (obj.abc.status === 200) {
              resolve(200);
            } else {
              reject(404);
            }
          } catch (error) {
            reject(error);
          }
        }, 2000);
      });
    },

    async test2() {
      try {
        const res = await this.getHttpData();
        console.log("liubbc test2 res: ", res);
      } catch (error) {
        console.log("liubbc test2 err: ", error);
      }
    },

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 手写Promise异步的方法如下: ``` // 定义Promise构造函数 function MyPromise(fn) { // 状态机,初始化为pending var state = 'pending'; // 成功结果 var value = null; // 失败原因 var reason = null; // 成功回调函数队列 var successCallback = []; // 失败回调函数队列 var failCallback = []; // resolve方法 function resolve(newValue) { if (state === 'pending') { state = 'fulfilled'; value = newValue; successCallback.forEach(function(cb) { cb(value); }); } } // reject方法 function reject(newReason) { if (state === 'pending') { state = 'rejected'; reason = newReason; failCallback.forEach(function(cb) { cb(reason); }); } } // then方法 this.then = function(onFulfilled, onRejected) { if (state === 'fulfilled') { onFulfilled(value); } if (state === 'rejected') { onRejected(reason); } if (state === 'pending') { successCallback.push(onFulfilled); failCallback.push(onRejected); } } // 执行fn函数 fn(resolve, reject); } ``` 使用方式为: ``` var promise = new MyPromise(function(resolve, reject) { setTimeout(function() { resolve('成功'); }, 1000); }); promise.then(function(value) { console.log(value); }, function(reason) { console.log(reason); }); ``` 这样就实现了一个简单的promise异步. ### 回答2: 手写Promise异步的实现: Promise是一种用于处理异步操作的机制,通过它可以更加方便地处理异步代码,避免了回调地狱问题。 下面是一个手写的简单Promise异步实现例子: ```javascript class MyPromise { constructor(executor) { this.status = 'pending'; // 初始状态为pending this.value = undefined; // 存储Promise的值 this.callbacks = []; // 存储then方法的回调函数 const resolve = (value) => { if (this.status === 'pending') { // 只能由pending状态转换为fulfilled this.status = 'fulfilled'; this.value = value; this.callbacks.forEach(callback => callback(value)); } }; const reject = (reason) => { if (this.status === 'pending') { // 只能由pending状态转换为rejected this.status = 'rejected'; this.value = reason; this.callbacks.forEach(callback => callback(null, reason)); } }; try { executor(resolve, reject); // 执行executor函数 } catch (error) { reject(error); // 若存在错误则reject } } then(onFulfilled, onRejected) { return new MyPromise((resolve, reject) => { const fulfilled = (value) => { try { const result = onFulfilled(value); if (result instanceof MyPromise) { result.then(resolve, reject); } else { resolve(result); } } catch (error) { reject(error); } }; const rejected = (reason) => { try { const result = onRejected(reason); if (result instanceof MyPromise) { result.then(resolve, reject); } else { resolve(result); } } catch (error) { reject(error); } }; if (this.status === 'fulfilled') { setTimeout(() => fulfilled(this.value)); // 异步执行onFulfilled函数 } else if (this.status === 'rejected') { setTimeout(() => rejected(this.value)); // 异步执行onRejected函数 } else { // 当前状态是pending时,将回调函数存储到callbacks this.callbacks.push(fulfilled); this.callbacks.push(rejected); } }); } } // 使用例子: const promise = new MyPromise((resolve, reject) => { setTimeout(() => { resolve('success'); }, 1000); }); promise.then((value) => { console.log(value); // 输出'success' }).catch((reason) => { console.error(reason); }); ``` 这个简单的Promise实现例子,我们根据Promise的状态定义了resolve和reject函数,同时使用了setTimeout模拟异步处理。在then方法,根据当前Promise的状态执行相应的回调函数,并处理返回值为Promise的情况。最后使用该Promise实例的时候,可以通过then方法获取resolve的值,或者通过catch方法处理reject的情况。 ### 回答3: 手写Promise异步,可以通过自己实现Promise的构造函数和其原型方法来完成。 首先定义一个Promise的构造函数,接收一个执行函数(executor)作为参数。在构造函数,需要定义三个状态常量:PENDING、FULFILLED和REJECTED,分别代表Promise的三种状态。同时还需要定义一个变量存储Promise的结果。构造函数,需要定义一个resolve函数和一个reject函数,用于改变Promise的状态,并传递结果。 接下来,需要定义Promise的原型方法,包括then方法和catch方法。then方法接收两个参数,分别是onFulfilled和onRejected,分别代表Promise状态变为FULFILLED和REJECTED时的回调函数。在then方法,根据当前Promise的状态,执行相应的回调函数,并将结果传递给下一个Promise。 catch方法用于捕获Promise错误,当之前的Promise状态变为REJECTED时,会执行catch方法的回调函数。 最后,在手动实现的Promise,任意时间只能处于一种状态,一旦Promise的状态确定,就不可以再次改变。 总的来说,手写Promise异步,需要定义Promise的构造函数,实现resolve和reject函数来改变Promise的状态。然后定义then方法和catch方法来处理结果或错误。这样就能实现一个简单的手动Promise异步函数了。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值