JavaScript Promises and Async/Await Quiz

Create an account and save your quiz results

Login and save your results

OR

Question 1/15

When running this code, what will be logged to the console?
async function exampleFunction() {
  try {
    return await Promise.reject('Failed');
  } catch (e) {
    console.log(e);
  }
}
exampleFunction();

Select your answer

Question 2/15

Why might using `Promise.all()` lead to performance issues compared to `Promise.allSettled()`?

Select your answer

Question 3/15

Which of these statements about error handling in async functions is true?

Select your answer

Question 4/15

What does the following code print to the console?
async function test() {
  await null;
  console.log('printed');
}
test();

Select your answer

Question 5/15

Which of the following is true about using `async` functions?

Select your answer

Question 6/15

Why does the following code not catch any errors?
async function example() {
  try {
    let data = await fetchNonExistent();
    console.log(data);
  } catch {
    console.log('An error occurred');
  }
}
example();

Select your answer

Question 7/15

Which of the following statements correctly describes `Promise.allSettled()`?

Select your answer

Question 8/15

How many times does 'A' get printed in the console when the following code is executed?
async function main() {
  console.log('A');
  await new Promise(resolve => setTimeout(resolve, 1000));
  console.log('A');
}
main();
console.log('A');

Select your answer

Question 9/15

Why is the following code considered bad practice?
async function loadData() {
  fetch('https://example.com/api1').then(response => response.json());
  fetch('https://example.com/api2').then(response => response.json());
}

Select your answer

Question 10/15

What will be the console output after the following code snippet?
async function func() {
  return 'hello world';
}

debugger;
console.log(await func());

Select your answer

Question 11/15

Why does the following code snippet cause an error?
async function start() {
  try {
    await JSON.parse('{ invalidJson }');
  } catch (error) {
    console.error('Caught Error:', error.message);
  }
}
start();

Select your answer

Question 12/15

What will be the console output of this JavaScript code?
async function run() {
  throw new Error('Something went wrong.');
}

run().catch(error => console.error(error.message));
console.log('End');

Select your answer

Question 13/15

In what scenario would using `Promise.race()` be beneficial?

Select your answer

Question 14/15

What would the output be after the execution of the following code?
async function process() {
  const p = new Promise(resolve => resolve('done'));
  return p.finally(() => 'cleaned');
}
process().then(console.log);

Select your answer

Question 15/15

Consider the following code. What does it output?
async function asyncOp(num) {
  return num * 2;
}

async function series() {
  console.log(await asyncOp(1));
  console.log(await asyncOp(2));
}

series();

Select your answer

Your Results

You did not answer any questions correctly.

Your Answers

Question 1/15
😊 Your answer was correct 🙁 Your answer was incorrect
When running this code, what will be logged to the console?
async function exampleFunction() {
  try {
    return await Promise.reject('Failed');
  } catch (e) {
    console.log(e);
  }
}
exampleFunction();

Available answers

The `Promise.reject('Failed')` throws an error, which is caught in the `catch (e)` block. Therefore, 'Failed' is logged to the console.
Question 2/15
😊 Your answer was correct 🙁 Your answer was incorrect
Why might using `Promise.all()` lead to performance issues compared to `Promise.allSettled()`?

Available answers

`Promise.all()` will reject immediately when any of the input promises rejects. This can lead to issues if you're performing multiple independent operations, and `Promise.allSettled()` is preferred to handle these scenarios where all outcomes are significant.
Question 3/15
😊 Your answer was correct 🙁 Your answer was incorrect
Which of these statements about error handling in async functions is true?

Available answers

You can use `try` and `catch` blocks to handle errors that occur in async functions due to rejected promises or explicit exceptions thrown within the function body.
Question 4/15
😊 Your answer was correct 🙁 Your answer was incorrect
What does the following code print to the console?
async function test() {
  await null;
  console.log('printed');
}
test();

Available answers

In this code, `await null;` is effectively a no-operation in terms of async handling. It does not throw an error, and the function proceeds to the next line, which is the `console.log('printed')`. Therefore, 'printed' is logged to the console.
Question 5/15
😊 Your answer was correct 🙁 Your answer was incorrect
Which of the following is true about using `async` functions?

Available answers

An `async` function always returns a Promise, regardless of whether any `await` expressions are used within it. The presence of `await` expressions does not change the fact that the function as a whole is asynchronous.
Question 6/15
😊 Your answer was correct 🙁 Your answer was incorrect
Why does the following code not catch any errors?
async function example() {
  try {
    let data = await fetchNonExistent();
    console.log(data);
  } catch {
    console.log('An error occurred');
  }
}
example();

Available answers

`fetchNonExistent` is not a defined function, so the error 'ReferenceError' is thrown even before the promise handling can be processed, leading to an immediate exit from the async function.
Question 7/15
😊 Your answer was correct 🙁 Your answer was incorrect
Which of the following statements correctly describes `Promise.allSettled()`?

Available answers

The `Promise.allSettled()` method returns a promise that resolves after all of the given promises have either resolved or rejected, with an array of objects that each describe the outcome of each promise.
Question 8/15
😊 Your answer was correct 🙁 Your answer was incorrect
How many times does 'A' get printed in the console when the following code is executed?
async function main() {
  console.log('A');
  await new Promise(resolve => setTimeout(resolve, 1000));
  console.log('A');
}
main();
console.log('A');

Available answers

The console will log 'A' three times. First, when console.log('A') is called in the `main` function, then immediately after `main()` is called, and finally after the 1-second delay with `setTimeout`.
Question 9/15
😊 Your answer was correct 🙁 Your answer was incorrect
Why is the following code considered bad practice?
async function loadData() {
  fetch('https://example.com/api1').then(response => response.json());
  fetch('https://example.com/api2').then(response => response.json());
}

Available answers

In the provided code, the fetch operations are asynchronous, and by not using `await` or returning the promises, any potential errors during fetching or JSON parsing are not handled, which can result in unhandled promise rejections.
Question 10/15
😊 Your answer was correct 🙁 Your answer was incorrect
What will be the console output after the following code snippet?
async function func() {
  return 'hello world';
}

debugger;
console.log(await func());

Available answers

The `debugger;` statement pauses execution, allowing for inspection. Once resumed, `console.log(await func())` logs the resolved promise value, 'hello world'.
Question 11/15
😊 Your answer was correct 🙁 Your answer was incorrect
Why does the following code snippet cause an error?
async function start() {
  try {
    await JSON.parse('{ invalidJson }');
  } catch (error) {
    console.error('Caught Error:', error.message);
  }
}
start();

Available answers

The error occurs because `JSON.parse` is a synchronous operation, and exceptions thrown are not converted into promise rejections, thus they don't get caught by the `await`. However, the `try...catch` still captures it.
Question 12/15
😊 Your answer was correct 🙁 Your answer was incorrect
What will be the console output of this JavaScript code?
async function run() {
  throw new Error('Something went wrong.');
}

run().catch(error => console.error(error.message));
console.log('End');

Available answers

The `run` function throws an error, which is caught and logged by the `.catch(error => console.error(error.message))` method. 'End' from `console.log('End')` is logged first because it is synchronous, and the error message is logged immediately after.
Question 13/15
😊 Your answer was correct 🙁 Your answer was incorrect
In what scenario would using `Promise.race()` be beneficial?

Available answers

`Promise.race()` returns the promise from the array that settles first, whether it is resolved or rejected. It's used when you need a result quickly from a series of potential sources.
Question 14/15
😊 Your answer was correct 🙁 Your answer was incorrect
What would the output be after the execution of the following code?
async function process() {
  const p = new Promise(resolve => resolve('done'));
  return p.finally(() => 'cleaned');
}
process().then(console.log);

Available answers

The `finally` method does not alter the value with which the promise resolves or rejects. Hence, the promise resolves with 'done', which is why 'done' is logged.
Question 15/15
😊 Your answer was correct 🙁 Your answer was incorrect
Consider the following code. What does it output?
async function asyncOp(num) {
  return num * 2;
}

async function series() {
  console.log(await asyncOp(1));
  console.log(await asyncOp(2));
}

series();

Available answers

`asyncOp` returns a promise that resolves to `num * 2`. The `series` function awaits these promises and logs the results 2 and 4 sequentially. Therefore, 2 and 4 are consecutively printed to the console.