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

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

Failed

undefined

Error: Failed

Question 2/15

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

Select your answer

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

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

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

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

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

What does the following code print to the console?

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

Select your answer

printed

undefined

TypeError: Cannot read property 'then' of null

Nothing gets printed

Question 5/15

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

Select your answer

An `async` function always returns a Promise.

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

`async` functions execute faster than normal functions.

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

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

An unhandled exception prevents the `catch` from executing.

`fetchNonExistent` is not defined.

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

JavaScript does not support error handling for undefined functions.

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.

Resolves once one of the given promises resolves or rejects.

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

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

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

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

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

Because promises are not awaited, leading to unhandled rejections.

Because `fetch` does not return a promise.

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

undefined

hello world

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

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

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

Something went wrong., End

End, Something went wrong.

Error: Something went wrong

End

Question 13/15

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

Select your answer

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

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

When you need to ignore the fastest promise to resolve.

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

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

cleaned

done

undefined

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

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

NaN, NaN

undefined, undefined

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

2, 4

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

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

Failed

undefined

Error: Failed

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()` resolves faster, making it unsuitable for non-blocking operations.

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

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

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

`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

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

What does the following code print to the console?

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

Available answers

printed

undefined

TypeError: Cannot read property 'then' of null

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

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

`async` functions execute faster than normal functions.

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.

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

An unhandled exception prevents the `catch` from executing.

`fetchNonExistent` is not defined.

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

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

Resolves once one of the given promises resolves or rejects.

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

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

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

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

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

Because promises are not awaited, leading to unhandled rejections.

Because `fetch` does not return a promise.

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

TypeError: Cannot await in console.log

undefined

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

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

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

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

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

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

When you need to ignore the fastest promise to resolve.

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

`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

cleaned

done

undefined

Promise { <state>: 'fulfilled', <value>: '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 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

NaN, NaN

undefined, undefined

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

2, 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.