使用 Promise 时如何跳出串行循环？

Question

我有一个长文本文件，我逐行循环以提取一些事件数据并将其存储在数据库中。该文件会定期更新顶部的新数据。发生这种情况时，我会再次运行文件以提取新事件，但是当我遇到数据库中已经存在的事件时我想停止（文件总是按从最新到最旧的顺序排列）。

使用this answer中描述的reduce()方法对问题Correct way to write loops for promise，我想出了这个函数来解析文件：

function parse(
    file)
{
    var lines = file.split("\n"),
        latestDate;

    return lines.reduce(function(promise, line) {
        return promise.then(function() {
            if (/* line matches date pattern */) {
                latestDate = line;
            } else if (/* line matches event pattern */) {
                return Event.createAsync(line, latestDate);
            }

            return promise;
        });
    }, Promise.resolve())
        .catch({ errorName: "uniqueViolated" }, 
            function() { /* ignore only the createAsync error */ });
}

createAsync() 数据库方法返回一个在保存事件时解决的承诺。如果数据库中已经存在该事件，它将引发异常，这会停止承诺链，因此不会解析文件的其余部分。该异常被函数末尾的catch() 处理程序捕获并忽略。我在 Node.js 中使用 Bluebird 3.0 承诺库。

此函数会依次循环遍历每一行，并在遇到已保存的事件时正确停止。但我想知道这是否是在处理承诺时打破循环的最佳方式。在函数末尾吞下抛出的异常似乎有点笨拙。

欢迎提出任何改进循环处理的建议。

解决方案？

以jib's answer 为基础，并考虑到Bergi's comment，也许我应该尝试他对我链接到的问题的非简化答案:)，我想出了这个解决方案：

function parse(
    file)
{
    var lines = file.split("\n"),
        latestDate;

    return promiseEach(lines, function(line) {
        if (/* line matches date pattern */) {
            latestDate = line;
        } else if (/* line matches event pattern */) {
            return Event.createAsync(line, latestDate)
                .catch({ errorType: "uniqueViolated" }, function() { return false; });
        }
    });
}

循环递归被移到一个通用函数promiseEach() 中，该函数循环遍历数组中的每个项目。如果迭代器函数返回一个 Promise，则在该 Promise 解决之前不会处理下一项。如果迭代器返回false，则循环结束，Lo-dash 样式：

function promiseEach(
    list,
    iterator,
    index)
{
    index = index || 0;

    if (list && index < list.length) {
        return Promise.resolve(iterator(list[index])).then(function(result) {
            if (result !== false) {
                return promiseEach(list, iterator, ++index);
            }
        });
    } else {
        return Promise.resolve();
    }
}

我认为这可以满足我的要求，但我想知道如果我在 4000 行文件上运行它是否会出现调用堆栈问题。

Answer 1

你所拥有的并没有真正打破循环。

对Event.createAsync 的每次调用都会立即成功返回一个promise，这意味着您总是对整个 数组进行归约。

因此，此循环生成的承诺链的长度将始终是文件中的总行数，减去在您的特定逻辑中既不符合日期也不符合事件模式的行数。

这是该承诺链的异步执行，稍后会在由于数据库中已存在事件而引发错误时终止。

您的代码有效，但您说这是一个长文本文件，因此它可能效率低下，特别是如果提前中断是常态而不是例外（从您的描述中听起来）。

因此，我会考虑使用递归方法：

function parse(file) {
  var latestDate;

  function recurse(lines, i) {
    if (i >= lines.length) return Promise.resolve();

    var line = lines[i];
    if (/* line matches date pattern */) {
      latestDate = line;
    } else if (/* line matches event pattern */) {
      return Event.createAsync(line, latestDate).then(() => recurse(lines, i + 1));
    }
    return recurse(lines, i + 1);
  }

  return recurse(file.split("\n"), 0);
}

递归方法的好处是承诺链在Event.createAsync 解析时异步扩展，并且仅在需要时进行。您也可以只停止调用recurse 来停止，即不需要Event.createAsync 抛出异常来爆发。

一种可视化差异的方法可能是将其与为火车铺设轨道进行比较，其中轨道代表承诺链，而火车代表异步操作的执行承诺：

使用reduce，您总是在火车启动前先放下整条轨道，无论火车在异常停止之前最终沿着轨道走多远。每次铺设整条轨道的成本你都吃掉了（可能不多，但可以加起来）。

在recurse 示例中，您正在移动的火车前及时铺设下一段轨道，例如Gromit in the finale of "The Wrong Trousers"，因此无需浪费时间铺设不需要的轨道。