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

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

Select your answer

Async functions provide no way to handle promise rejections.

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

Async functions automatically handle all errors internally without propagation.

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

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

Promise { : 'fulfilled', : 42 }

undefined

Error: data is not defined

Question 3/15

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

Select your answer

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

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

Resolves only when all promises in the iterable resolve successfully.

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

Question 4/15

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

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

Select your answer

A promise that resolves to 123

undefined

A promise that immediately rejects

123

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

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

Async functions cannot consume synchronous parsing methods.

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

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

done

undefined

cleaned

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

Error: Error occurred

undefined

Error occurred

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

Question 8/15

What would be the final output of this code?

async function main() {
  try {
    const response = await fetch('https://example.com');
    console.log('Response received');
  } catch (error) {
    console.log('Fetch error');
  }
  console.log('Completed');
}
main();

Select your answer

Response received

Response received, Completed

Fetch error, Completed

Completed

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

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

`fetchNonExistent` is not defined.

JavaScript does not support error handling for undefined functions.

An unhandled exception prevents the `catch` from executing.

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

TypeError: Cannot await in console.log

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

undefined

hello world

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

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

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

Because promises are not awaited, leading to unhandled rejections.

Question 12/15

Which option correctly demonstrates how to handle multiple promise rejections?

Select your answer

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

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

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

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

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

What will the following code output?

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

Select your answer

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

Hello

Promise { : 'pending' }

Undefined

Question 15/15

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

Select your answer

`async` functions execute faster than normal functions.

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

An `async` function always returns a Promise.

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

Your Results

You did not answer any questions correctly.

Your Answers

Question 1/15

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

Async functions provide no way to handle promise rejections.

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

Async functions automatically handle all errors internally without propagation.

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

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

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

undefined

Error: data is not defined

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

Question 3/15

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

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

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

Resolves only when all promises in the iterable resolve successfully.

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

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

A promise that resolves to 123

undefined

A promise that immediately rejects

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.

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

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

Async functions cannot consume synchronous parsing methods.

`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 6/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' }

done

undefined

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

Error: Error occurred

undefined

Error occurred

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

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

😊 Your answer was correct 🙁 Your answer was incorrect

What would be the final output of this code?

async function main() {
  try {
    const response = await fetch('https://example.com');
    console.log('Response received');
  } catch (error) {
    console.log('Fetch error');
  }
  console.log('Completed');
}
main();

Available answers

Response received

Response received, Completed

Fetch error, Completed

Completed

If the fetch operation succeeds, 'Response received' is logged, followed by 'Completed'. The `catch` block won't execute here. The final expected output is 'Response received, Completed'.

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

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

`fetchNonExistent` is not defined.

JavaScript does not support error handling for undefined functions.

An unhandled exception prevents the `catch` from executing.

`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 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' }

undefined

hello world

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

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

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

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

Which option correctly demonstrates how to handle multiple promise rejections?

Available answers

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

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

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

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

`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 13/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 14/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>: 'fulfilled', <value>: 'Hello' }

Hello

Promise { <state>: 'pending' }

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

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

`async` functions execute faster than normal functions.

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

An `async` function always returns a Promise.

An `async` function can only have one `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.