javascript - typescript - while 循环 for Promise

Question

我有一个大数组，它被分成更小的 block 。然后我对每个 block 进行异步调用:

  myFunc(arrObjs: any[], chunkSize: number): Promise<any> {
    let result = Promise.resolve(); // To start the chain

    while(arrObjs.length) {
      // Extracting array chunk
      let chunk = arrObjs.splice(0, chunkSize);
      // Building the chain
      result = result.then(() => {
        return someAsynFunc(
          chunk
        );
      });
    }
    return result;
  }

以上是我的解决方案。我需要按顺序运行异步函数(系列 promise )，因此我构建了一系列 promise 。

有没有更好的方法来做到这一点？

Answer 1

是的，您可以使用reduce模式:

function myFunc(arrObjs: any[], chunkSize: number): Promise<any> {
    const chunks : any[] = [];
    while (arrObjs.length) {
        chunks.push(arrObjs.splice(0, chunkSize));
    }

    return chunks.reduce((p : Promise<any>, chunk : any[]) => {
        return p.then(() => someAsyncFunc(chunk));
    }, Promise.resolve());
  }

(我认为我的类型注释是正确的；如果没有，希望您可以阅读它......)

请注意，我保留了您原来的行为，实际上是从 arrObjs 数组中删除数据，但通常我不提倡像这样更改从调用者传递的对象。

这是一个例子:

function myFunc(arrObjs, chunkSize) {
  const chunks = [];
  while (arrObjs.length) {
    chunks.push(arrObjs.splice(0, chunkSize));
  }

  return chunks.reduce((p, chunk) => {
    return p.then(() => someAsyncFunc(chunk));
  }, Promise.resolve());
}

function someAsyncFunc(chunk) {
  console.log("Start handling", JSON.stringify(chunk));
  return new Promise(resolve => {
    setTimeout(() => {
      console.log("Done handling", JSON.stringify(chunk));
      resolve();
    }, 800);
  });
}

const array = [0, 1, 2, 4, 5, 6, 7, 8, 9];
myFunc(array, 3).then(() => {
  console.log("Done");
});

<小时/>

另请注意，上面的代码在处理它们之前提前从数组中删除所有 block 。如果您想在处理它们时执行此操作(这会与使用该数组的其他任何内容产生串扰，这可能会添加/删除/等)，您可以做同样的事情，只是没有减少:

// Cross-talky version
function myFunc(arrObjs : any[], chunkSize : number) : Promise<any> {
  return new Promise<any>(function processChunk(resolve : function) {
    const chunk : any[] = arrObjs.splice(0, chunkSize);
    if (chunk.length == 0) {
      resolve();
    } else {
      someAsyncFunc(chunk).then(() => processChunk(resolve));
    }
  });
}

// Cross-talky version
function myFunc(arrObjs, chunkSize) {
  return new Promise(function processChunk(resolve) {
    const chunk = arrObjs.splice(0, chunkSize);
    if (chunk.length == 0) {
      resolve();
    } else {
      someAsyncFunc(chunk).then(() => processChunk(resolve));
    }
  });
}

function someAsyncFunc(chunk) {
  console.log("Start handling", JSON.stringify(chunk));
  return new Promise(resolve => {
    setTimeout(() => {
      console.log("Done handling", JSON.stringify(chunk));
      resolve();
    }, 800);
  });
}

const array = [0, 1, 2, 4, 5, 6, 7, 8, 9];
myFunc(array, 3).then(() => {
  console.log("Done");
});
setTimeout(() => {
  array.splice(2, 0, 'cross', 'talk');
}, 1000);