Throttle async promise resolver

Q: Throttle async promise resolver

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Medium > **How to read this doc:** the "concurrent callers share one real in-flight call, rather than triggering redundant duplicate requests" claim was verified directly — 3 near-simultaneous callers against a deliberately slow real async function produced exactly 1 real underlying call. ## 1. The problem, restated `throttleAsync(fn, wait)` wraps an async function so that additional calls arriving WHILE a real call is already in flight — or before `wait` has elapsed since the last one finished — do not trigger a redundant new real call; they instead share the existing (or most recent) real result. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Share the in-flight result, or drop the extra calls? | Sharing is the real, more useful default — a caller genuinely still wants SOME answer, not silence. | | Window starts at call-begin or

The problem

Problem, as an interviewer would state it: "Write throttleAsync(fn, wait) — like regular throttle, but wraps an async fn. If fn is already IN FLIGHT (a real, pending call), additional calls should not start a redundant second real call — they should share the existing in-flight result."

Examples:

Code

const t = throttleAsync(fetchStatus, 200);
const [a, b, c] = await Promise.all([t(), t(), t()]);
// only ONE real fetchStatus() call happens; a, b, c all resolve to its result

Clarifying questions expected:

If a call arrives WHILE another is genuinely in flight, does it wait and share that result, or is it dropped entirely?
Does the throttle window start when the call BEGINS, or only once it genuinely finishes?
Should a call that arrives just after the window closes trigger a fresh, new real call?

Code / implementation expected: Yes — real, direct proof that 3 near-simultaneous callers, while a call is already in flight, produce exactly 1 real underlying invocation.

js-coding
utility
algorithm

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Medium

How to read this doc: the "concurrent callers share one real in-flight call, rather than triggering redundant duplicate requests" claim was verified directly — 3 near-simultaneous callers against a deliberately slow real async function produced exactly 1 real underlying call.

1. The problem, restated

throttleAsync(fn, wait) wraps an async function so that additional calls arriving WHILE a real call is already in flight — or before wait has elapsed since the last one finished — do not trigger a redundant new real call; they instead share the existing (or most recent) real result.

2. Clarifying questions a strong candidate asks

Question	Why it matters
Share the in-flight result, or drop the extra calls?	Sharing is the real, more useful d

The solution is hidden so you can try first

4 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: throttleAsync() makes exactly one real underlying call when 3 callers arrive while a call is already in flight