AI for Async/Await: Stop Drowning in Callbacks

End-of-lesson check

15 questions · take it digitally for instant feedback at tendril.neural-forge.io/learn/quiz/end-builders-ai-coding-AI-and-async-await-teen

1. What does the `await` keyword actually wait for?

   1. The console to finish printing
   2. The user to provide input
   3. The entire page to finish loading
   4. A promise to resolve (or reject)

2. Why does a `fetch()` call return a Promise instead of the actual data?

   1. The API requires all responses to be wrapped in Promises
   2. Browsers have a bug that returns Promises instead of data
   3. Fetch always fails and returns a Promise to handle the error
   4. Fetching data from a server takes time, so JS doesn't freeze while waiting

3. What goes wrong if you use `await` without a `try/catch` block?

   1. The code runs but prints nothing useful
   2. Variables will be set to null
   3. Network errors or rejections will crash the program with an unhandled error
   4. The browser will refuse to run the code

4. You need to fetch data from three different APIs that don't depend on each other. What's the most efficient approach?

   1. Call fetch() three times without await
   2. Await each fetch() call one after another in a loop
   3. Chain three .then() calls together
   4. Use Promise.all() to fetch all three in parallel

5. What happens to your code execution when you write `const data = await fetch(url)`?

   1. The code continues running and `data` becomes available immediately as undefined
   2. The browser freezes until the data arrives
   3. The fetch request is cancelled
   4. Execution pauses at that line until the Promise resolves, then `data` gets the resolved value

6. What does adding the `async` keyword before a function do?

   1. Makes the function error-free
   2. Runs the function in the background
   3. Automatically returns a Promise and allows using `await` inside it
   4. Makes the function run faster

7. What is the main problem with deeply nested `.then().then().then()` chains?

   1. They become hard to read and maintain (callback hell)
   2. They use too much memory
   3. They run slower than async/await
   4. The browser blocks them for security reasons

8. What does Promise.all() return if one of the Promises rejects?

   1. An array with the error at that position
   2. An object describing which ones failed
   3. The first rejected value, ignoring successful ones
   4. It waits for all to finish regardless

9. Why should every `await` expression have a nearby `try/catch`?

   1. Uncaught promise rejections can crash Node.js applications
   2. Async code won't run without it
   3. It's required by JavaScript syntax
   4. The browser will reload the page

10. What value does `await` give you when a Promise rejects?

    1. undefined
    2. An empty object
    3. null
    4. It throws an error that you must catch

11. A student writes: `await fetch(url); console.log(data);` Why might `console.log(data)` fail?

    1. The `data` variable was never assigned — they forgot to store the await result
    2. The URL is wrong
    3. fetch() doesn't return usable data
    4. Console.log doesn't work with async

12. What's the benefit of asking an AI to convert your `.then()` chains to async/await?

    1. The code becomes easier to read and debug
    2. The code will run faster
    3. You don't need to understand Promises anymore
    4. The AI fixes all bugs automatically

13. What happens if you `await` something that isn't a Promise?

    1. It returns undefined
    2. The code crashes the browser
    3. The await wraps it in a resolved Promise automatically
    4. JavaScript throws an error immediately

14. You call an API that sometimes takes 5 seconds and sometimes fails. What should you always include when using await with this API?

    1. A timeout function
    2. A retry button
    3. A loading spinner
    4. try/catch error handling

15. What does this code print? `async function test() { return 5; } console.log(test());`

    1. undefined
    2. An error
    3. 5
    4. A Promise object