“功能上”累积承诺值

Question

说我有这个：

function getAllPromises(key: string, val: any): Promise {

 const subDeps = someHash[key];
 const acc = {}; // accumulated value

 return subDeps.reduce(function (p, k) {

  return p.then(v => getAllPromises(k, v)).then(function (v) {
        acc[k] = v;
        return acc;
   });

 }, Promise.resolve(val));

}

有没有办法避免不得不声明一个单独的变量：

const acc = {}; // accumulated value

并以某种方式从承诺链中返回？

最终，acc 变量是从承诺链中得到解决的，但我想知道我是否可以以某种方式避免不得不在链“外部”声明它。

编辑：类似这样的种子数据如下所示：

  {
    'one': [function (v) {
      return Promise.resolve('one');
    }],

    'two': ['one', function (v) {
      return Promise.resolve('two');
    }],

    'three': ['one', 'two', function (v) {
      return Promise.resolve('three');
    }],

  }

它只是一个声明性依赖树。依赖关系可以并行解决；但在它们运行时可能会有效地阻塞。例如，如果我有这样的功能：

function foo(one,two,three){


}

我想注入这 3 个依赖项。它们可以“并行”采购，但three 将被阻止，直到one 和two 被采购。

subDeps 变量是什么？在 key="three" 的情况下，subDeps 是 ['one','two']。

Answer 1

在这里，我有点冒险，我认为任何子节点的subDeps 的整个列表都可以并行加载。在深入研究这个问题时，我认为没有理由不这样做。事实上，我能看到的唯一潜在问题是，高于但不低于这一点的某个值可能是一个承诺，因此，您甚至可以从这个特定的递归函数中实现承诺。 ..

但是……

这是我认为合理的重构。如果缺少一些明显的需求，请告诉我。

const appendKeyValue = (dict, [key, value]) => {
  dict[key] = value;
  return dict;
};

const getKeyValuePair = hash => key =>
  getRefactoredPromises(hash, hash[key])
    .then(value => [key, value]);

const getRefactoredPromises = (someHash, subDeps) => {
  return Promise.all(subDeps.map(getKeyValuePair(someHash)))
    .then(pairs => pairs.reduce(appendKeyValue, {}));
};

事实上，如果我对这个重构的看法是正确的，那么你甚至不需要其中的 Promise。它只是变成：

const appendKeyValue = (dict, [key, value]) => {
  dict[key] = value;
  return dict;
};

const getKeyValuePair = hash => key =>
  [key, getRefactoredHash(hash, hash[key])];

const getRefactoredHash = (someHash, subDeps) =>
  subDeps.map(getKeyValuePair(someHash))
         .reduce(appendKeyValue, {});

如果这个调用的根级别恰好是一个承诺，那么此时应该是无关紧要的，除非我遗漏了什么（现在是早上 6:20，我还没有闭上眼睛）。

Answer 2

您可以将第二个参数的数组传递给.reduce()，在.reduce() 回调中使用析构赋值来获取Promise 并传递对象

return subDeps.reduce(([p, acc], k) => 
         [p.then(v => getAllPromises(k, v)).then(v => Object.assign(acc, {[k]:v}))
         , acc]; 
       }, [Promise.resolve(val), {}]).shift()//.then(result => /* result : acc */)