loopAwaits

Reports using await expressions inside loops.

✅ This rule is included in the performance logical presets.

Using await inside a loop causes each iteration to wait for the previous iteration to complete before starting the next one. This sequential execution can significantly slow down your code when the awaited operations are independent and could be executed in parallel.

Consider collecting promises in an array during the loop and then using Promise.all() to await all of them in parallel. This allows all the asynchronous operations to run concurrently, which is typically much faster than running them one at a time.

async function 
function processItems(items: string[]): Promise<void>
processItems(
items: string[]
items: string[]) {
  for (const 
const item: string
item of 
items: string[]
items) {
    await 
function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
MDN Reference
fetch(`/api/${
const item: string
item}`);
  }
}

async function 
function updateRecords(ids: number[]): Promise<void>
updateRecords(
ids: number[]
ids: number[]) {
  let 
let i: number
i = 0;
  while (
let i: number
i < 
ids: number[]
ids.
Array<number>.length: number
Gets or sets the length of the array. This is a number one higher than the highest index in the array.
length) {
    await 
const database: {
    update(id: number): Promise<void>;
}
database.
function update(id: number): Promise<void>
update(
ids: number[]
ids[
let i: number
i]);
    
let i: number
i += 1;
  }
}

async function 
function processItems(items: string[]): Promise<void>
processItems(
items: string[]
items: string[]) {
  const 
const promises: Promise<Response>[]
promises = 
items: string[]
items.
Array<string>.map<Promise<Response>>(callbackfn: (value: string, index: number, array: string[]) => Promise<Response>, thisArg?: any): Promise<Response>[]
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@param ― callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
@param ― thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
map((
item: string
item) => 
function fetch(input: string | URL | Request, init?: RequestInit): Promise<Response> (+1 overload)
MDN Reference
fetch(`/api/${
item: string
item}`));
  await 
var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.
PromiseConstructor.all<Promise<Response>[]>(values: Promise<Response>[]): Promise<Response[]> (+1 overload)
Creates a Promise that is resolved with an array of results when all of the provided Promises
resolve, or rejected when any Promise is rejected.
@param ― values An array of Promises.
@returns ― A new Promise.
all(
const promises: Promise<Response>[]
promises);
}

async function 
function updateRecords(ids: number[]): Promise<void>
updateRecords(
ids: number[]
ids: number[]) {
  await 
var Promise: PromiseConstructor
Represents the completion of an asynchronous operation
Promise.
PromiseConstructor.all<Promise<void>[]>(values: Promise<void>[]): Promise<void[]> (+1 overload)
Creates a Promise that is resolved with an array of results when all of the provided Promises
resolve, or rejected when any Promise is rejected.
@param ― values An array of Promises.
@returns ― A new Promise.
all(
ids: number[]
ids.
Array<number>.map<Promise<void>>(callbackfn: (value: number, index: number, array: number[]) => Promise<void>, thisArg?: any): Promise<void>[]
Calls a defined callback function on each element of an array, and returns an array that contains the results.
@param ― callbackfn A function that accepts up to three arguments. The map method calls the callbackfn function one time for each element in the array.
@param ― thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
map((
id: number
id) => 
const database: {
    update(id: number): Promise<void>;
}
database.
function update(id: number): Promise<void>
update(
id: number
id)));
}

Options

This rule is not configurable.

When Not To Use It

If your asynchronous operations must be executed sequentially you may wish to disable this rule for those specific cases. For example, if each operation depends on the result of the previous one, or if you need to avoid overwhelming a rate-limited API, parallel calls may not be an option.

Equivalents in Other Linters

Made with ❤️‍🔥 around the world by the Flint team and contributors.

loopAwaits

Examples

Options

When Not To Use It

Further Reading

Equivalents in Other Linters