Javascript 如何从异步/等待内部承诺返回错误_Javascript_Async Await_Es6 Promise

Javascript 如何从异步/等待内部承诺返回错误

javascript

Javascript 如何从异步/等待内部承诺返回错误,javascript,async-await,es6-promise,Javascript,Async Await,Es6 Promise,我最初编写的代码带有承诺，但由于for循环必须使用async/await 代码现在可以工作了，但我不知道如何抛出这个错误，它的工作原理相当于拒绝承诺 let createGroup=(data)=>{ return new Promise((resolve,reject)=>{ if(check.isEmpty(data.groupName)){ reject('G

我最初编写的代码带有承诺，但由于for循环必须使用async/await

代码现在可以工作了，但我不知道如何抛出这个错误，它的工作原理相当于拒绝承诺

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如何在从数据库获取数据时检查错误。因此，它最终进入了承诺的捕获块。并调用错误的apiResponse

我不知道如何扔掉这个错误，这个错误相当于拒绝承诺

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);
            })

那么，您应该

抛出而不是返回it:-）异步函数中的异常将导致返回的承诺被拒绝
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;
}

我不知道如何扔掉这个错误，这个错误相当于拒绝承诺
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);
            })

那么，您应该抛出而不是返回it:-）异步函数中的异常将导致返回的承诺被拒绝
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;
}

您好，Bergi，在for（）完成后，try语句中是否需要返回1以退出异步？不，不需要退出函数，除非您希望用1实现您的承诺。如果一个异步函数退出时没有任何return
语句，那么它通常的工作方式就像它有一个return undefined
语句一样，并且承诺是通过undefined
实现的。hi Bergi，在for（）完成后，try语句中是否需要返回1来退出异步？不，不需要退出函数，除非你想用1来兑现你的承诺。如果一个异步函数退出时没有任何return
语句，那么它通常的工作方式就好像它有一个returnundefined
语句一样，并且承诺是通过undefined
实现的。