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 need to ignore the fastest promise to resolve.

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.

Question 2/15

What will the following code output?

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

Select your answer

Promise { : 'pending' }

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

Undefined

Hello

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

Error: Something went wrong

End, Something went wrong.

End

Something went wrong., End

Question 4/15

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

Select your answer

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

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

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

Promise { : 'fulfilled', : 42 }

Error: data is not defined

undefined

Question 6/15

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

Select your answer

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

An `async` function always returns a Promise.

`async` functions execute faster than normal functions.

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

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

Resolves only when all promises in the iterable resolve successfully.

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

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

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

undefined

Error: Error occurred

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

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

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

TypeError: Cannot await in console.log

undefined

hello world

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

Failed

Error: Failed

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

Processing, Success!

Success!, Processing

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

Flowed, Started

Started

Started, Flowed

Question 15/15

What does the following code print to the console?

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

Select your answer

undefined

printed

TypeError: Cannot read property 'then' of null

Nothing gets printed

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 need to ignore the fastest promise to resolve.

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.

`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

What will the following code output?

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

Available answers

Promise { <state>: 'pending' }

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

Undefined

Hello

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

Error: Something went wrong

End, Something went wrong.

End

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 4/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.allSettled()` is a synchronous operation.

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

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

Error: data is not defined

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

😊 Your answer was correct 🙁 Your answer was incorrect

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

Available answers

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

An `async` function always returns a Promise.

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

Resolves only when all promises in the iterable resolve successfully.

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

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

undefined

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

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

TypeError: Cannot await in console.log

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

Failed

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

Processing, Success!

Success!, Processing

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

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

Flowed, Started

Started

Started, Flowed

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

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

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.