javascript - NodeJS 中的嵌套 Promise

Question

我正在 NodeJS 中编写一个服务，用于检索项目列表。对于每一项，我都必须创建一个计数器来指示可用项目的数量。因此，如果商店中存在该商品，计数器只会增加并解决 promise (因为我确信最多会有一件库存)。

否则，如果有库存，我必须检查可用件的确切数量。

如果不是前两种情况之一，我将解决 promise 并转到下一个项目。

问题出在第二种情况下，因为在解决(当前项目的)主要 promise 之前，我必须等待检索仓库中零件计数器的调用结束。由于它是异步代码，因此当它当前进入第二个“else”时，它会触发对库存中计件计数器的调用，并立即解析 promise ，而无需等待调用结束。我怎样才能解决这个串联的 promise ？

这是代码:

let promises: any[] = [];
for (let i = 0, itemsLength = itemList.length; i < itemsLength; i++) {
let currentItem = itemList[i];
promises.push(
    new Promise(function(resolve: Function, reject: Function) {
        act({
            ...call the service to retrieve the item list
        })
        .then(function(senecaResponse: SenecaResponse < any > ) {
            if (senecaResponse && senecaResponse.error) {
                reject(new Error(senecaResponse.error));
            }
            currentItem.itemDetails = senecaResponse.response;

            currentItem.counters = {
                available: 0
            };

            if (currentItem.itemDetails && currentItem.itemDetails.length) {
                for (let k = 0, detailsLength = currentItem.itemDetails.length; k < detailsLength; k++) {
                    let currentItemDetail = currentItem.itemDetails[k];
                    if (currentItemDetail.val === "IN_THE_STORE") {
                        currentItem.counters.available++;

                        resolve();
                    } else if (currentItemDetail.courseType === "IN_STOCK") {
                        act({
                                ...call the service to retrieve the counter in stock
                            })
                            .then(function(stockResponse: SenecaResponse < any > ) {
                                if (stockResponse && stockResponse.error) {
                                    reject(new Error(stockResponse.error));
                                } else {
                                    currentItem.counters.available = stockResponse.response;
                                }
                                resolve();
                            })
                            .catch(function(error: Error) {
                                options.logger.error(error);
                                reject(error);
                            })
                    } else {
                        resolve();
                    }
                }
            } else {
                resolve();
            }
        })
        .catch(function(error: Error) {
            options.logger.error(error);
            reject(error);
        })
    })
);

}
   return Promise.all(promises);

Answer 1

请记住，您可以通过 then 和 catch 创建 promise 链，其中每个处理程序都会转换分辨率值。由于您的 act() 显然返回了一个 Promise，因此您的代码中根本不需要 new Promise 。相反，只需使用链即可。

如果产品存在，您需要执行子查询，这不是问题； then(和 catch)始终返回 Promise，因此，如果您从回调中返回一个简单的值，它们创建的 Promise 就会用该值来实现，但如果您返回一个 Promise，它们创建的 Promise 将解析为该 Promise(它们等待另一个 Promise 结算并以相同的方式结算)。

以下是如何根据问题中的代码执行此操作的草图:

// Result is a promise for an array of populated items
return Promise.all(itemList.map(currentItem => {
    act(/*...query using `currentItem`...*/)
    .then(senecaResponse => {
        if (!senecaResponse || senecaResponse.error) {
            // Does this really happen? It should reject rather than fulfilling with something invalid.
            throw new Error((senecaResponse && senecaResponse.error) || "Invalid response");
        }
        currentItem.itemDetails = senecaResponse.response;
        currentItem.counters = {
            available: 0
        };
        return Promise.all((currentItem.itemDetails || []).map(currentItemDetail => {
            if (currentItemDetail.courseType === "IN_STOCK") {
                return act(/*...query using `currentItemDetail`...*/).then(stockResponse => {
                    currentItem.counters.available = stockResponse.response;
                });
            }
            if (currentItemDetail.val === "IN_THE_STORE") {
                currentItem.counters.available++;
            }
            // (We don't care what value we return, so the default `undefined` is fine; we
            // don't use the array from `Promise.all`
        }))
        .then(() => currentItem); // <== Note that this means we convert the array `Promise.all`
                                  // fulfills with back into just the `currentItem`
    });
}));