Loading... Login Loading... Register

JavaScript Promises and Async/Await Quiz

Want to learn more than this quiz offers you? Have a look at my Frontend web development courses.

Create an account and save your quiz results

Login and save your results

First Name *

Last Name *

Email *

Password *

Confirm Password *

I agree to the Terms of Service & Privacy Policy.

Add me to your newsletter.

Question 1/15

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

Select your answer

When you are interested in resolving after all promises have been successfully resolved.

When you are interested in the result of only the first promise that settles, whether resolved or rejected.

When you want to execute all promises and settle only on success.

When you need to ignore the fastest promise to resolve.

Question 2/15

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

Select your answer

Awaiting a promise in an async function can't throw an error.

Errors thrown from async functions can be handled using `try` and `catch`.

Async functions provide no way to handle promise rejections.

Async functions automatically handle all errors internally without propagation.

Question 3/15

Observe the code below. What will the logs be?

async function appFlow() {
  const result = await new Promise(resolve => setTimeout(() => resolve('Flowed'), 500));
  console.log(result);
}
appFlow();
console.log('Started');

Select your answer

Started, Flowed

Flowed

Flowed, Started

Started

Question 4/15

Which option correctly demonstrates how to handle multiple promise rejections?

Select your answer

Promise.all(promisesArray).catch(error => handleError(error));

Promise.allSettled(promisesArray).then(results => handleResults(results));

Promise.race(promisesArray).catch(errors => handleErrors(errors));

Promise.any(promisesArray).then(result => handleResult(result));

Question 5/15

Determine the correct outcome for this scenario.

let data;
async function fetchData() {
  const result = await Promise.resolve(42);
  data = result;
}
fetchData();
console.log(data);

Select your answer

Error: data is not defined

undefined

Promise { : 'fulfilled', : 42 }

Question 6/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

Failed

Promise { : 'rejected', : 'Failed' }

Error: Failed

undefined

Question 7/15

Which of the following statements accurately describes `Promise.any()`?

Select your answer

Resolves as soon as any of the promises in the iterable resolves.

Rejects when any one of the promises in the iterable is rejected.

Resolves only when all promises in the iterable resolve successfully.

Settles as soon as any promise in the iterable settles, irrespective of its outcome.

Question 8/15

What does the following code print to the console?

async function test() {
  await null;
  console.log('printed');
}
test();

Select your answer

undefined

printed

Nothing gets printed

TypeError: Cannot read property 'then' of null

Question 9/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

JavaScript does not support error handling for undefined functions.

An unhandled exception prevents the `catch` from executing.

`fetchNonExistent` is not defined.

`await` is not correctly used in `try` block.

Question 10/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

Promise { : 'fulfilled', : 'cleaned' }

undefined

cleaned

done

Question 11/15

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

Select your answer

`Promise.all()` does not handle fulfilled promises correctly.

`Promise.all()` resolves faster, making it unsuitable for non-blocking operations.

`Promise.all()` waits for all promises to resolve, and any rejection will fail the entire batch.

`Promise.allSettled()` is a synchronous operation.

Question 12/15

What will the value of `result` be in the following code snippet?

async function example() {
  try {
    const result = await Promise.reject('Error occurred');
  } catch (error) {
    return error;
  }
}
example().then(console.log);

Select your answer

Promise { : 'rejected', : 'Error occurred' }

Error occurred

Error: Error occurred

undefined

Question 13/15

What values are logged by the following code?

async function main() {
  console.log('start');
  setTimeout(() => console.log('middle'), 0);
  await Promise.resolve('end');
  console.log('end');
}
main();

Select your answer

start, end, middle

middle, start, end

start, end

start, middle, end

Question 14/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

NaN, NaN

undefined, undefined

2, 4

Promise { : 'fulfilled', : 2 }, Promise { : 'fulfilled', : 4 }

Question 15/15

Given the following code, what does `someAsyncFunction` return?

function someAsyncFunction() {
  return Promise.resolve(123);
}
someAsyncFunction();

Select your answer

undefined

A promise that immediately rejects

123

A promise that resolves to 123

Your Results

You did not answer any questions correctly.

Your Answers

Question 1/15

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

When you are interested in resolving after all promises have been successfully resolved.

When you are interested in the result of only the first promise that settles, whether resolved or rejected.

When you want to execute all promises and settle only on success.

When you need to ignore the fastest promise to resolve.

`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 2/15

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

Awaiting a promise in an async function can't throw an error.

Errors thrown from async functions can be handled using `try` and `catch`.

Async functions provide no way to handle promise rejections.

Async functions automatically handle all errors internally without propagation.

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 3/15

😊 Your answer was correct 🙁 Your answer was incorrect

Observe the code below. What will the logs be?

async function appFlow() {
  const result = await new Promise(resolve => setTimeout(() => resolve('Flowed'), 500));
  console.log(result);
}
appFlow();
console.log('Started');

Available answers

Started, Flowed

Flowed

Flowed, Started

Started

'Started' is logged immediately after `appFlow()` before the promise resolves. After 500ms, 'Flowed' is logged when the promise inside `appFlow()` resolves.

Question 4/15

😊 Your answer was correct 🙁 Your answer was incorrect

Which option correctly demonstrates how to handle multiple promise rejections?

Available answers

Promise.all(promisesArray).catch(error => handleError(error));

Promise.allSettled(promisesArray).then(results => handleResults(results));

Promise.race(promisesArray).catch(errors => handleErrors(errors));

Promise.any(promisesArray).then(result => handleResult(result));

`Promise.allSettled(promisesArray)` will return a promise that resolves after all input promises have settled, regardless of whether they fulfilled or rejected, allowing us to handle each promise's result individually.

Question 5/15

😊 Your answer was correct 🙁 Your answer was incorrect

Determine the correct outcome for this scenario.

let data;
async function fetchData() {
  const result = await Promise.resolve(42);
  data = result;
}
fetchData();
console.log(data);

Available answers

Error: data is not defined

undefined

Promise { <state>: 'fulfilled', <value>: 42 }

Immediately after `fetchData()` is invoked, `console.log(data);` runs before the promise resolves. Hence, `data` is `undefined` at the time of the log.

Question 6/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

Failed

Promise { <state>: 'rejected', <reason>: 'Failed' }

Error: Failed

undefined

The `Promise.reject('Failed')` throws an error, which is caught in the `catch (e)` block. Therefore, 'Failed' is logged to the console.

Question 7/15

😊 Your answer was correct 🙁 Your answer was incorrect

Which of the following statements accurately describes `Promise.any()`?

Available answers

Resolves as soon as any of the promises in the iterable resolves.

Rejects when any one of the promises in the iterable is rejected.

Resolves only when all promises in the iterable resolve successfully.

Settles as soon as any promise in the iterable settles, irrespective of its outcome.

`Promise.any()` returns a promise that resolves as soon as any of the promises in the iterable is resolved. If all of the promises are rejected, it returns an AggregateError.

Question 8/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

undefined

printed

Nothing gets printed

TypeError: Cannot read property 'then' of null

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 9/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

JavaScript does not support error handling for undefined functions.

An unhandled exception prevents the `catch` from executing.

`fetchNonExistent` is not defined.

`await` is not correctly used in `try` block.

`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 10/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

Promise { <state>: 'fulfilled', <value>: 'cleaned' }

undefined

cleaned

done

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 11/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()` does not handle fulfilled promises correctly.

`Promise.all()` resolves faster, making it unsuitable for non-blocking operations.

`Promise.all()` waits for all promises to resolve, and any rejection will fail the entire batch.

`Promise.allSettled()` is a synchronous operation.

`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 12/15

😊 Your answer was correct 🙁 Your answer was incorrect

What will the value of `result` be in the following code snippet?

async function example() {
  try {
    const result = await Promise.reject('Error occurred');
  } catch (error) {
    return error;
  }
}
example().then(console.log);

Available answers

Promise { <state>: 'rejected', <reason>: 'Error occurred' }

Error occurred

Error: Error occurred

undefined

In this example, `await Promise.reject('Error occurred')` will throw an error which is caught by the `catch` block, returning the error message as `result`. Therefore, `example().then(console.log)` will log 'Error occurred'.

Question 13/15

😊 Your answer was correct 🙁 Your answer was incorrect

What values are logged by the following code?

async function main() {
  console.log('start');
  setTimeout(() => console.log('middle'), 0);
  await Promise.resolve('end');
  console.log('end');
}
main();

Available answers

start, end, middle

middle, start, end

start, end

start, middle, end

The execution order is 'start', then the microtask queue resolves the awaited promise logging 'end', and finally the setTimeout callback logs 'middle'. Microtasks (e.g., promise callbacks) are executed before the next task (from the task queue, such as `setTimeout`).

Question 14/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

NaN, NaN

undefined, undefined

2, 4

Promise { <state>: 'fulfilled', <value>: 2 }, Promise { <state>: 'fulfilled', <value>: 4 }

`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.

Question 15/15

😊 Your answer was correct 🙁 Your answer was incorrect

Given the following code, what does `someAsyncFunction` return?

function someAsyncFunction() {
  return Promise.resolve(123);
}
someAsyncFunction();

Available answers

undefined

A promise that immediately rejects

123

A promise that resolves to 123

The `someAsyncFunction` explicitly returns a Promise object that resolves with the value of 123. Therefore, the function call returns a promise that resolves to 123.