javascript - 这真的是一个异步 "for-like"循环吗？

Question

我试图更多地了解 Promise 和异步编程。我试图使用 Promise 制作一个异步 for 循环(是的，我知道有很多库可以完成此任务，但它们不会教我事情是如何工作的)。

假设我想迭代一个数组，并在执行其他操作时“每次更新”将一个函数应用于一个元素。所以我做了这个“类似异步 for 循环”的函数:

function asyncFor_(elements, worker, index) {
    return new Promise((resolve, reject) => {
         process.nextTick(()=>{
             if (index < elements.length) {
                 try {
                    worker(elements[index])  
                    resolve(asyncFor_(elements, worker, index+1))   
                 } catch(e) {
                     reject()
                 }
             } else {
                 resolve()             
             }
         })
    })
}

并用这个进行测试:

function logEnd() {
    console.log('End')
}
function logErr(e) {
    console.log(e) //Received
    console.log('I dont like 3. GTFO.')
}
function logItem(item) {
    if (item === 3) {
        throw Error('3? GTFO.')
    }
    console.log(item)
}
console.log('Begin')
asyncFor_([1,2,3,4,5], logItem, 0)
    .then(logEnd)
    .catch(logErr)
asyncFor_([6,7,8,9], logItem, 0)
    .then(logEnd)
    .catch(logErr)
 console.log('Displayed after begin and before the rest')

输出为:

Begin
1
6
2
7
8
I don't like 3. GTFO
9
End (End from the second asyncFor_ call)

我认为这工作得很好。但同时我也有疑问。也许我误解了结果。我错过了什么？这种“异步”是一种错觉还是真的异步？

Answer 1

是的，这很好，是的，它确实是异步的(两个并发循环的输出日志也证明了这一点)。

但是它看起来有点像 Promise constructor antipattern ，并且通过避免这种情况，您可以大大简化您的代码:

function nextTick() {
    return new Promise(resolve => {
        process.nextTick(resolve);
    });
}

function asyncFor_(elements, worker, index) {
    return nextTick().then(() => {
        if (index < elements.length) {
            worker(elements[index]);
            return asyncFor_(elements, worker, index+1);
        }
    });
}

将代码放入 then 回调中，您就可以免费获得 try-catch。始终以尽可能低的水平做出 promise ! :-)