承诺拒绝不能正确传播错误

如何解决承诺拒绝不能正确传播错误

我收到一个复杂的对象，假设它看起来像这样：

complexObject: {
    fruits: string[],vegetables: string[],milk: [] | [{
        expirationDate: string,quantity: string
    }]
}

因此，逻辑是，当我收到一个空对象（milk只是[]）时，verifyObject方法将返回未定义的（进一步的逻辑更加复杂，并且必须收到未定义的...）;使用空/未定义对象调用该方法时，情况相同。

牛奶的唯一验证应如下所示： 如果我们有牛奶，那么它需要同时有quantity和expirationDate，否则应该返回false。 问题是，当我发送这样的对象时：

{
    'fruits': ['apples','bananas'],'vegetables': ['tomatoes'],'milk': [{
        'quantity': '10'
    }]
}

在checkAndAssign方法中，它会看到错误并打印console.log，但它不会在那里停止，它将对象添加到result中。 另外，在verifyObject方法中，它将进入catch块，但在上方它不会引发错误，而是将解决promise，返回结果...

当我收到错误消息并传播错误时，我想停止执行...

这是代码：

verifyObject(complexObject) {
    return new Promise((resolve,reject) => {
        const result = {};
        const propertiesEnum = ['fruits','vegetables','milk'];

        if (!complexObject) {
            resolve({ result: undefined });
        } else {
            this.checkAndAssign(complexObject,result)
                .catch((err) => {
                    console.log('enter error');
                    reject({ message: err });
                })
            if (!Object.keys(result).length) {
                console.log('resolve with undefined');
                resolve({ result: undefined });
            }
            console.log('resolve good');
            resolve({ result });
        }

    })
}

private checkAndAssign(complexObject,result) {
    return new Promise((resolve,reject) => {
        for (const property of complexObject) {
            if(complexObject[property] && Object.keys(complexObject[property]).length)
            if(property === 'milk' && this.verifyMilk(complexObject[property]) === false) {
                console.log('rejected');
                reject('incomplete');
            }
            Object.assign(result,{[property]: complexObject[property]})
            console.log('result is...:>',result);
        }
        console.log('final result:>',result);
        resolve(result);
    });
}

private verifyMilk(milk:any): boolean {
    for(const item of milk) {
        if(!(item['expirationDate'] && item['quantity'])) {
            return false;
        }
    }
    return true;
}

解决方法

调用reject不会终止您从中调用的功能。 reject只是一个普通的函数调用。调用完成后，调用它的函数将继续。

如果您不想这样做，请使用return：

private checkPropertyAndAssignValue(complexObject,result) {
    return new Promise((resolve,reject) => {
        for (const property of complexObject) {
            if(complexObject[property] && Object.keys(complexObject[property]).length)
            if(property === 'milk' && this.verifyMilk(complexObject[property]) === false) {
                console.log('rejected');
                reject('incomplete');
                return; // <================================================ here
            }
            Object.assign(result,{[property]: complexObject[property]})
            console.log('result is...:>',result);
        }
        console.log('final result:>',result);
        resolve(result);
    });
}

然后verifyObject需要等待checkPropertyAndAssignValue的诺言的兑现。 verifyObject的代码成为显式承诺创建反模式的牺牲品：它不应该使用new Promise，因为它已经有checkPropertyAndAssignValue的承诺。避免使用反模式也有助于避免此错误：

verifyObject(complexObject) {
    const result = {};
    const propertiesEnum = ['fruits','vegetables','milk'];

    if (!complexObject) {
        return Promise.resolve({ result: undefined });
    }

    return this.checkPropertyAndAssignValue(complexObject,result)
        .then(() => {
            if (!Object.keys(result).length) {
                console.log('resolve with undefined');
                return { result: undefined };
            }
            console.log('resolve good');
            return { result };
        })
        .catch((err) => {
            console.log('enter error');
            throw { message: err }; // *** Will get caught by the promise mechanism and turned into rejection
        });
}

---

作为替代：如果您正在为现代环境编写此代码，则可能会发现async函数和await更加熟悉，因为它们使用相同的结构（throw ，try，catch），您习惯使用同步代码。例如：

async verifyObject(complexObject) {
    const result = {};
    const propertiesEnum = ['fruits','milk'];

    if (!complexObject) {
        return { result: undefined };
    }

    try {
        await this.checkPropertyAndAssignValue(complexObject,result);
//      ^^^^^−−−−− waits for the promise to settle
        if (!Object.keys(result).length) {
            console.log('return undefined');
            return { result: undefined };
        }
        console.log('return good');
        return { result };
    } catch (err) {
        console.log('enter error');
        throw { message: err }; // *** FWIW,suggest making all rejections Error instances
                                // (even when using promises directly)
    }
}

private async checkPropertyAndAssignValue(complexObject,result) {
    // *** Note: This used to return a promise but didn't seem to have any asynchronous
    //     code in it. I've made it an `async` function,so if it's using something
    //     that returns a promise that you haven't shown,include `await` when getting
    //     its result.
    for (const property of complexObject) {
        if(complexObject[property] && Object.keys(complexObject[property]).length)
        if(property === 'milk' && this.verifyMilk(complexObject[property]) === false) {
            throw 'incomplete'; // *** FWIW,suggest making all rejections Error instances
                                // (even when using promises directly)
        }
        Object.assign(result,{[property]: complexObject[property]})
        console.log('result is...:>',result);
    }
    console.log('final result:>',result);
    return result;
}