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

Choose the correct statement about `await` keyword:

Select your answer

`await` can also be used in regular functions.

`await` blocks all JavaScript execution during waiting period.

`await` immediately resolves the promise and moves on.

`await` can only be used inside functions defined with `async`.

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

TypeError: Cannot await in console.log

Promise { : 'fulfilled', : 'hello world' }

hello world

undefined

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

What will the following code output?

async function test() {
  return await Promise.resolve('Hello');
}
test().then(console.log);

Select your answer

Promise { : 'pending' }

Hello

Promise { : 'fulfilled', : 'Hello' }

Undefined

Question 5/15

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

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

Select your answer

123

A promise that immediately rejects

A promise that resolves to 123

undefined

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

Something went wrong., End

End, Something went wrong.

Error: Something went wrong

End

Question 7/15

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

Select your answer

Settles after all given promises have settled, regardless of their outcomes.

Is an alias for `Promise.all()`.

Rejects if any of the given promises reject, otherwise resolves.

Resolves once one of the given promises resolves or rejects.

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

Because multiple fetch requests cannot be executed simultaneously in async functions.

Because `response.json()` is not required to parse JSON data.

Because `fetch` does not return a promise.

Because promises are not awaited, leading to unhandled rejections.

Question 9/15

What is often the primary motivation for using `Promise.any()` over `Promise.all()`?

Select your answer

`Promise.all()` is deprecated and `Promise.any()` is the new standard.

`Promise.any()` serializes promise execution for simplicity.

`Promise.any()` resolves faster by only waiting for one promise to fulfill, enhancing performance when racing conditions are beneficial.

`Promise.any()` avoids all rejected states, providing cleaner error handling.

Question 10/15

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

Select your answer

An `async` function can only have one `await` expression.

`async` functions execute faster than normal functions.

An `async` function always returns a Promise.

An `async` function is synchronous until it encounters an `await` expression.

Question 11/15

What will be the value of `x` after executing the following code?

let x = 10;
(async function() {
  x += await 3;
  console.log(x);
})();

Select your answer

Error

Promise { : 'fulfilled', : 3 }

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

undefined

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

done

cleaned

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

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

undefined

Error: Failed

Failed

Question 14/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 want to execute all promises and settle only on success.

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

When you need to ignore the fastest promise to resolve.

Question 15/15

Which option correctly demonstrates how to handle multiple promise rejections?

Select your answer

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

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

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

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

Your Results

You did not answer any questions correctly.

Your Answers

Question 1/15

😊 Your answer was correct 🙁 Your answer was incorrect

Choose the correct statement about `await` keyword:

Available answers

`await` can also be used in regular functions.

`await` blocks all JavaScript execution during waiting period.

`await` immediately resolves the promise and moves on.

`await` can only be used inside functions defined with `async`.

The `await` keyword is only valid inside async functions. It pauses the execution of the function and waits for the Promise to resolve.

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

TypeError: Cannot await in console.log

Promise { <state>: 'fulfilled', <value>: 'hello world' }

hello world

undefined

The `debugger;` statement pauses execution, allowing for inspection. Once resumed, `console.log(await func())` logs the resolved promise value, 'hello world'.

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

😊 Your answer was correct 🙁 Your answer was incorrect

What will the following code output?

async function test() {
  return await Promise.resolve('Hello');
}
test().then(console.log);

Available answers

Promise { <state>: 'pending' }

Hello

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

Undefined

The function `test` is an async function that immediately returns the result of `await Promise.resolve('Hello')`. Even though `await` is used, the resolved value is directly returned as the function's resolved promise, so `test().then(console.log)` will log 'Hello' to the console.

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

123

A promise that immediately rejects

A promise that resolves to 123

undefined

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.

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

Something went wrong., End

End, Something went wrong.

Error: Something went wrong

End

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

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

Settles after all given promises have settled, regardless of their outcomes.

Is an alias for `Promise.all()`.

Rejects if any of the given promises reject, otherwise resolves.

Resolves once one of the given promises resolves or rejects.

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

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

Because multiple fetch requests cannot be executed simultaneously in async functions.

Because `response.json()` is not required to parse JSON data.

Because `fetch` does not return a promise.

Because promises are not awaited, leading to unhandled rejections.

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

😊 Your answer was correct 🙁 Your answer was incorrect

What is often the primary motivation for using `Promise.any()` over `Promise.all()`?

Available answers

`Promise.all()` is deprecated and `Promise.any()` is the new standard.

`Promise.any()` serializes promise execution for simplicity.

`Promise.any()` resolves faster by only waiting for one promise to fulfill, enhancing performance when racing conditions are beneficial.

`Promise.any()` avoids all rejected states, providing cleaner error handling.

`Promise.any()` is useful when you need the earliest successfully resolved promise, such as when contacting several servers or services to respond, and you only need a successful response from one.

Question 10/15

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

An `async` function can only have one `await` expression.

`async` functions execute faster than normal functions.

An `async` function always returns a Promise.

An `async` function is synchronous until it encounters an `await` expression.

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

😊 Your answer was correct 🙁 Your answer was incorrect

What will be the value of `x` after executing the following code?

let x = 10;
(async function() {
  x += await 3;
  console.log(x);
})();

Available answers

Error

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

The right-hand side of the `+=` operator is `await 3`, which resolves to `3` as a resolved promise is created for any non-promise value. Thus, the value of `x` becomes `13`.

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

undefined

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

done

cleaned

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

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

undefined

Error: Failed

Failed

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

Question 14/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 want to execute all promises and settle only on success.

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

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

😊 Your answer was correct 🙁 Your answer was incorrect

Which option correctly demonstrates how to handle multiple promise rejections?

Available answers

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

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

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

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

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