Question

我有一个解析器函数macroBuilder()通过文本和解析宏。一些宏解析为文本，并且还有嵌套宏需要另一个传递。该函数返回一个字符串。

我将嵌套视为：

let fragments = [];
fragments.promises = [];
fragments.push = function() {
  let fragments = this;
  for (let i = 0; i < arguments.length; i++) {
    if (typeof arguments[i].then === 'function') {
      let id =  Date.now() + i + this.length;
      let promise = arguments[i]
        .then( function(id, val) {
          fragments[fragments.indexOf(id)] = val;
        }
        .bind(undefined, id))
        .catch( function(id, err) {
          fragments[fragments.indexOf(id)] = '';
        }
        .bind(undefined, id) );
      this.promises.push(promise);
      arguments[i] = id;
    }
  }
  return Array.prototype.push.apply(this, arguments);
}

最后，我做了：

await Promise.all(fragments.promises).then(pieces => {
  console.log('Promise.all(fragments.promises) resolved');
});

然后当我浏览我的标记化文本时，我会这样做：

textMacro(obj) {
  fragments.push(obj['text'])
},
anotherMacro(obj) {
  ...
},
nestedMacro(obj) {
  fragments.push(
    resolveMacro(obj['name'])
      .then(res => {
          return macroBuilder(res);
      }
  );
}

这很好用，期望我的宏被解码为文本会立即被推送到fragments数组，而嵌套宏会在所有常规宏已经解析为文本后在下一次传递时被解码。

我需要按照它们出现的顺序处理宏，因为处理某些宏有副作用，需要考虑这些副作用，然后处理顺序宏中的下一个宏。

尝试通过将常规文本结果转换为承诺来处理此问题，因此textMacro()函数如下所示：

textMacro(obj) {
  fragments.push(
    new Promise((resolve, reject) => {
      resolve(obj['text']);
    })
  );
}

这样，我希望一切都以正确的顺序得到解决。但是，我的textMacro()和其他非嵌套类型宏解析器立即解析了Promise。

我做错了什么？

强制承诺解决订单

0 个答案: