Typescript/ES7中异步/等待的有限并行性

Question

我一直在尝试打字稿，但我现在有点卡在如何有效地使用async/wait上。

我正在向数据库中插入一组记录，我需要获得每次插入返回的ID列表。下面的简化示例一般来说是有效的，但它并不像我所希望的那么优雅，而且是完全连续的。

async function generatePersons() {
    const names = generateNames(firstNames, lastNames);
    let ids = []
    for (let name of names) {
        const id = await db("persons").insert({
            first_name: name.firstName,
            last_name: name.lastName,
        }).returning('id');
        ids.push(id[0])
    }
    return ids
}

我试图使用map来避免手动创建ids列表，但我可以让它工作。

我还希望有有限的并行性。因此，我的异步调用应该在一定的限制下并行进行，例如，我只希望有10个打开的请求，但不希望有更多。

有没有一种合理优雅的方式来实现这种有限的并行性与异步/等待在TypeScript或Javascript ES7？或者我试图让这个html" target="_blank">功能做一些它不打算做的事情？

_{PS：我知道数据库有批量插入方法，这个例子有点做作，因为我可以使用这些方法来解决这个特定问题。但这让我想知道，在一般情况下，我没有可用的预定义批量方法，例如网络请求}

Answer 1

有没有一种合理优雅的方法来实现这种有限的并行性与异步/等待在TypeScript或Javascript ES7

你必须使用Promise。全部。i、 e.收集数组中的所有promise并等待promise。全部（[all，the，stuff]）。

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise/all

Answer 2

检查异步并行库，它提供了各种帮助函数，使执行并行操作变得容易。使用这个库，您的代码可以看起来像这样...

async function generatePersons(): Promise<number[]> {
    const names = generateNames(firstNames, lastNames);
    return await Parallel.map(names, async (name) => 
        await db("persons").insert({
            first_name: name.firstName,
            last_name: name.lastName,
        }).returning('id'));
}

如果你想将实例的数量限制在一次四个，你可以简单地执行以下操作。。。

Parallel.concurrency = 4;

Answer 3

promise。all将允许您等待所有请求停止完成，而不会阻止它们的创建。

然而，有时听起来你确实想阻止。具体来说，听起来你想在任何给定的时间限制飞行中的请求数量。这是我突然想到的（但还没有完全测试过！）

async function asyncThrottledMap<T, U>(maxCount: number, array: T[], f: (x: T) => Promise<U>) {
    let inFlight = new Set<Promise<U>>();
    const result: Promise<U>[] = [];

    // Sequentially add a Promise for each operation.
    for (let elem of array) {

        // Wait for any one of the promises to complete if there are too many running.
        if (inFlight.size >= maxCount) {
            await Promise.race(inFlight);
        }

        // This is the Promise that the user originally passed us back.
        const origPromise = f(elem);
        // This is a Promise that adds/removes from the set of in-flight promises.
        const handledPromise = wrap(origPromise);
        result.push(handledPromise);
    }

    return Promise.all(result);

    async function wrap(p: Promise<U>) {
        inFlight.add(p);
        const result = await p;
        inFlight.delete(p);
        return result;
    }
}

上面，inFlight是当前正在执行的一组操作。

结果是打包的Promises的数组。每个打包的promise基本上都是添加或删除inFlight操作集合中的操作。如果有太多的运行中操作，那么这将使用Promise.race来完成任何一个运行中操作。

希望这有所帮助。