如何從承諾中的異步/等待返回錯誤

Question

我最初用 Promise 編寫代碼，但由於 for 循環不得不使用 async/await。

該代碼現在可以工作，但是我不知道如何拋出可以等效於拒絕 promise 的錯誤。

let createGroup=(data)=>{
                return new Promise((resolve,reject)=>{
                    if(check.isEmpty(data.groupName)){
                        reject('GroupId not Valid');
                    }
                    else{
                        let newGroup= new ExpenseModel({
                            groupId:'G-'+shortid.generate(),
                            groupName:data.groupName,
                            contributors:data.contributorObjIds,
                            timeCreated:time.now().format(),
                            creator:data.ownerId
                        })
                        newGroup.save((err,group)=>{
                            if(err){
                                reject(`Group Not Created ${err}`);
                            }else{
                                data.groupdata=group;
                                console.log("group created",data);
                                resolve(data);
                            }
                        })
                    }
                })
            }

            let updateUserData= async (data)=>{
                try{
                    for(user of data.contributorIds){
                        const res=await UserModel.findOne({'userId':user});
                        res.groups.push(data.groupdata._id);
                        const resSave=await res.save();
                        let id='GroupCreated'+user;

                        eventEmitter.emit('getGroup',user);    
                    }

                    return 1;
                }
                catch(e){
                    return e;
                }
            }



            createGroup(data)
            .then(updateUserData)
            .then((resolve)=>{
                let apiResponse = response.generate(false, 'Group created', 200, resolve);
                console.log(apiResponse);
            })
            .catch((err)=>{
                let apiResponse = response.generate(true, 'Group not saved', 400, null);
                console.log('group creation failed',err);
                 res.send(apiResponse);
            })

在updateUserData中，如何在從 db 獲取數據時檢查錯誤。 這樣它最終會進入 promise 的 catch 塊。 並調用錯誤的apiResponse 。

Answer 1

我不知道如何拋出可以等同於拒絕 promise 的錯誤。

好吧，你應該throw它而不是return它:-) async function中的異常將導致返回的 promise 拒絕。

async function updateUserData(data) {
    try {
        for (user of data.contributorIds) {
            const res = await UserModel.findOne({'userId':user});
            res.groups.push(data.groupdata._id);
            const resSave = await res.save();
            let id = 'GroupCreated'+user;
            eventEmitter.emit('getGroup', user);
        }
        return 1;
    } catch(e){
        throw e;
//      ^^^^^
    }
}

但是，使用try / catch錯誤只是為了重新拋出它而不做任何其他事情是沒有意義的，你應該讓異常冒泡。 簡化為

async function updateUserData(data) {
    for (user of data.contributorIds) {
        const res = await UserModel.findOne({'userId':user});
        res.groups.push(data.groupdata._id);
        const resSave = await res.save();
        let id = 'GroupCreated'+user;
        eventEmitter.emit('getGroup', user);
    }
    return 1;
}

Answer 2

在常規的try..catch中，我們可以分析錯誤，如果無法處理，可能會重新拋出它。 同樣的事情也適用於 Promise。

如果我們在.catch中拋出，那么控件將轉到下一個最近的錯誤處理程序。 如果我們處理錯誤並正常完成，那么它會繼續到最近的successful.then 處理程序。

在下面的示例中， .catch成功處理了錯誤：

new Promise((resolve, reject) => {

  throw new Error("Whoops!");

}).catch(function(error) {

  alert("The error is handled, continue normally");

}).then(() => alert("Next successful handler runs"));

但是在每個捕獲中，如果它仍未處理，我們可以拋出一個新錯誤，我們可以確保它不會阻塞代碼並最終返回它。

// the execution: catch -> catch -> then
new Promise((resolve, reject) => {

  throw new Error("Whoops!");

}).catch(function(error) { // (*)

  if (error instanceof MyCustomEror) {
    // handle it
  } else {
    alert("Can't handle such error");

    throw error; // throwing this or another error jumps to the next catch
  }

}).then(function() {
  /* doesn't run here */
}).catch(error => { // (**)

  alert(`The unknown error has occurred: ${error}`);
  // don't return anything => execution goes the normal way

});