async/await & Error Handling

8. Practice Problems

1. Write an async function that returns 42.
   ✨ Show Answer

   a1.js

   async function f() { return 42; }
   f().then(console.log);

   Run Copy

2. Use await on a 50ms timer.
   ✨ Show Answer

   a2.js

   (async () => {
       await new Promise(r => setTimeout(r, 50));
       console.log("done");
   })();

   Run Copy

3. Catch a rejected promise with try/catch.
   ✨ Show Answer

   a3.js

   (async () => {
       try { await Promise.reject("x"); }
       catch (e) { console.log("caught:", e); }
   })();

   Run Copy

4. Run three independent waits in parallel.
   ✨ Show Answer

   a4.js

   const w = (v, ms) => new Promise(r => setTimeout(() => r(v), ms));
   (async () => {
       const [a, b, c] = await Promise.all([w(1, 10), w(2, 10), w(3, 10)]);
       console.log(a, b, c);
   })();

   Run Copy

5. Show that throwing inside an async function makes the returned promise reject.
   ✨ Show Answer

   a5.js

   async function bad() { throw new Error("x"); }
   bad().catch(e => console.log("rejected:", e.message));

   Run Copy

6. Compare sequential and parallel timing for 5 50-ms tasks.
   ✨ Show Answer

   a6.js

   const w = (ms) => new Promise(r => setTimeout(r, ms));
   (async () => {
       const ms = [50,50,50,50,50];
       let t = Date.now();
       for (const n of ms) await w(n);
       console.log("seq:", Date.now() - t);
       t = Date.now();
       await Promise.all(ms.map(w));
       console.log("par:", Date.now() - t);
   })();

   Run Copy

7. Promisify setTimeout as sleep and use with await.
   ✨ Show Answer

   a7.js

   const sleep = ms => new Promise(r => setTimeout(r, ms));
   (async () => {
       console.log("start");
       await sleep(30);
       console.log("after 30ms");
   })();

   Run Copy

8. Build retry(fn, n) using async/await.
   ✨ Show Answer

   a8.js

   async function retry(fn, n) {
       for (let i = 0; i < n; i++) {
           try { return await fn(); }
           catch (e) { if (i === n - 1) throw e; }
       }
   }
   let i = 0;
   retry(() => ++i < 3 ? Promise.reject("x") : Promise.resolve("ok"), 5)
       .then(console.log);

   Run Copy

9. Show the wrong way: forgetting to await an async function.
   ✨ Show Answer

   a9.js

   async function val() { return 42; }
   async function main() {
       const v = val();        // missing await — v is a Promise
       console.log("got:", v);
       console.log("awaited:", await v);
   }
   main();

   Run Copy

10. Use try/catch/finally to log "cleanup" on both success and failure.
    ✨ Show Answer

    a10.js

    (async () => {
        try { await Promise.reject("err"); }
        catch (e) { console.log("caught", e); }
        finally { console.log("cleanup"); }
    })();

    Run Copy

11. Why is awaiting in a for-of loop sometimes correct (despite being slower)?
    ✨ Show Answer

    Answer: Sometimes order matters or each step depends on the previous result (e.g. paginated APIs, transactional writes). In those cases sequential is the right choice. Use Promise.all only when items are independent.

12. Show top-level await syntactically (with explanation, since runner can't simulate modules).
    ✨ Show Answer

    Inside an ES module file (.mjs or with "type": "module"), this works at the top level:

    // app.mjs
    const config = await fetch("/config.json").then(r => r.json());
    export default config;

13. Write a function that fetches three URLs in parallel and returns when ALL settle.
    ✨ Show Answer

    a13.js

    const fake = (v, ms, fail) => new Promise((res, rej) =>
        setTimeout(() => fail ? rej(v) : res(v), ms));
    (async () => {
        const r = await Promise.allSettled([
            fake("a", 10),
            fake("b", 10, true),
            fake("c", 10)
        ]);
        console.log(r);
    })();

    Run Copy

14. Implement a simple async queue with concurrency 1.
    ✨ Show Answer

    a14.js

    function serial() {
        let last = Promise.resolve();
        return task => (last = last.then(task, task));
    }
    const run = serial();
    run(() => new Promise(r => setTimeout(() => { console.log("a"); r(); }, 30)));
    run(() => new Promise(r => setTimeout(() => { console.log("b"); r(); }, 30)));

    Run Copy

15. Convert a Promise chain (.then.then.catch) to async/await.
    ✨ Show Answer

    a15.js

    const step = v => Promise.resolve(v + 1);
    
    (async () => {
        try {
            const a = await step(1);
            const b = await step(a);
            const c = await step(b);
            console.log(c);
        } catch (e) { console.log("err", e); }
    })();

    Run Copy

16. In one paragraph, explain why async/await beats raw Promises.
    ✨ Show Answer

    Answer: async/await reuses try/catch for error handling, eliminates the "forgot to return" trap inside .then, lets you mix sync and async errors in one place, and keeps control flow visually linear so you can use ordinary if/for with awaits inline. Underneath, it is still Promises — so all the combinators still work — but the surface code is dramatically easier to read and refactor.