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

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

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

An unhandled exception prevents the `catch` from executing.

`fetchNonExistent` is not defined.

JavaScript does not support error handling for undefined functions.

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

Flowed, Started

Started

Flowed

Started, Flowed

Question 3/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.

Async functions automatically handle all errors internally without propagation.

Async functions provide no way to handle promise rejections.

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

Question 4/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.all(promisesArray).catch(error => handleError(error));

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

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

undefined

TypeError: Cannot await in console.log

hello world

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

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

JSON parsing is synchronous, and errors aren't caught by `await`.

Async functions cannot consume synchronous parsing methods.

Invalid JSON will cause the `await` keyword to fail processing.

`try..catch` cannot catch errors from JSON parsing.

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

Promise { : 'fulfilled', : 42 }

undefined

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

Resolves only when all promises in the iterable resolve successfully.

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

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

Question 11/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 `fetch` does not return a promise.

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

Because promises are not awaited, leading to unhandled rejections.

Question 12/15

What does the following code print to the console?

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

Select your answer

TypeError: Cannot read property 'then' of null

printed

undefined

Nothing gets printed

Question 13/15

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

Select your answer

Resolves once one of the given promises resolves or rejects.

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.

Question 14/15

What is the output of the following code?

async function mainProcess() {
  return new Promise(resolve => resolve('Success!'));
}

mainProcess().then(console.log);
console.log('Processing');

Select your answer

Processing

Success!

Success!, Processing

Processing, Success!

Question 15/15

Choose the correct statement about `await` keyword:

Select your answer

`await` blocks all JavaScript execution during waiting period.

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

`await` immediately resolves the promise and moves on.

`await` can also be used in regular functions.

Your Results

You did not answer any questions correctly.

Your Answers

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

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

An unhandled exception prevents the `catch` from executing.

`fetchNonExistent` is not defined.

JavaScript does not support error handling for undefined functions.

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

Flowed, Started

Started

Flowed

Started, Flowed

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

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

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

Async functions automatically handle all errors internally without propagation.

Async functions provide no way to handle promise rejections.

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

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

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.all(promisesArray).catch(error => handleError(error));

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

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

undefined

TypeError: Cannot await in console.log

hello world

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

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

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

JSON parsing is synchronous, and errors aren't caught by `await`.

Async functions cannot consume synchronous parsing methods.

Invalid JSON will cause the `await` keyword to fail processing.

`try..catch` cannot catch errors from JSON parsing.

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

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

undefined

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

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

Resolves only when all promises in the iterable resolve successfully.

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

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

`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 11/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 `fetch` does not return a promise.

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

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

TypeError: Cannot read property 'then' of null

printed

undefined

Nothing gets printed

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

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

Resolves once one of the given promises resolves or rejects.

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.

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

😊 Your answer was correct 🙁 Your answer was incorrect

What is the output of the following code?

async function mainProcess() {
  return new Promise(resolve => resolve('Success!'));
}

mainProcess().then(console.log);
console.log('Processing');

Available answers

Processing

Success!

Success!, Processing

Processing, Success!

'Processing' is printed first as it is logged immediately after `mainProcess()`, and then 'Success!' is logged once the promise resolves.

Question 15/15

😊 Your answer was correct 🙁 Your answer was incorrect

Choose the correct statement about `await` keyword:

Available answers

`await` blocks all JavaScript execution during waiting period.

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

`await` immediately resolves the promise and moves on.

`await` can also be used in regular functions.

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