Node.js
Retry pattern
Learn the async retry pattern.
Retry pattern
The retry pattern retries an async job if it fails. Example: async function retry(fn, maxAttempts) { for (let attempt = 1; attempt <= maxAttempts; attempt++) { try { return await fn(attempt); } catch (e) { lastError = e; } } throw lastError; }.
Inside try the fn(attempt) call runs. On success the result is returned; on throw catch stores the error and the loop moves on. Up to maxAttempts tries are made; if all fail the last error is thrown. This is the standard way to handle transient network errors: the server might be busy or the connection might drop. The attempt counter increases each try, telling the function which attempt it is on (useful for backoff).
Catching errors with try/catch
The core of the retry pattern is the try/catch block. try { return await fn(attempt); } catch (e) { lastError = e; }. If fn throws the catch catches it and stores it in lastError; the loop continues.
The catch (e) parameter receives the error object. e.message gives the error description. You can log it: console.log("Attempt " + attempt + " failed: " + e.message). This lets you track which attempt failed and why. If all attempts are exhausted throw lastError forwards the last error to the caller. This lets the caller know an error occurred. Retry is only suitable for transient errors; permanent errors (wrong URL) always stay failed.
Exercise Write the retry function
Write async function retry(fn, maxAttempts): let lastError; and a for (let attempt = 1; attempt <= maxAttempts; attempt++) loop. In the body try { return await fn(attempt); } catch (e) { lastError = e; console.log("Attempt " + attempt + " failed: " + e.message); }. After the loop throw lastError;. main() is ready.
Show example solution
async function retry(fn, maxAttempts) {
let lastError;
for (let attempt = 1; attempt <= maxAttempts; attempt++) {
try {
return await fn(attempt);
} catch (e) {
lastError = e;
console.log("Attempt " + attempt + " failed: " + e.message);
}
}
throw lastError;
}
async function main() {
let count = 0;
const fn = async function(attempt) {
count++;
if (count < 3) throw new Error("Failed");
return "Success (attempt " + attempt + ")";
};
const result = await retry(fn, 5);
console.log(result);
}
main();
Test yourself
-
What happens if retry(fn, 3) succeeds on the third try?
await retry(fn, 3)
- Throws an error
- Returns the result
- Continues the loop
- fn is not called
Show answer
Returns the result — If try succeeds the result is returned and the loop ends.
-
Match each piece to its role
- try
- Attempts the job
- catch
- Catches the error
- maxAttempts
- Attempt limit
- throw lastError
- Throws the last error
-
Complete the catch block
try {
return await fn(attempt);
} ____ (e) { lastError = e; }
Show answer
try {
return await fn(attempt);
} catch (e) { lastError = e; }
Next lesson: Debounce and throttle
