Asynchronous Javascript

What is a callback function in JavaScript?

• A function that is called immediately after it is defined.

• A function that returns a promise.

• A function passed as an argument to another function to be executed later.

• A function that is executed before the main function.

Which of the following is true about JavaScript promises?

• They are used to handle synchronous operations only.

• They represent the completion or failure of asynchronous operations.

• They are only used with setTimeout.

• Promises cannot be chained.

In which JavaScript version were promises introduced?

• ES5

• ES6

• ES7

• ES8

What are the possible states of a JavaScript promise?

• Started, Pending, Completed

• Resolved, Completed, Failed

• Pending, Fulfilled, Rejected

• Waiting, Running, Finished

What does the async keyword do when used with a function in JavaScript?

• Makes the function run immediately.

• Allows the function to run as a generator.

• Allows the function to handle asynchronous code with await.

• Automatically makes the function return null.

Which of the following is a correct example of using await?

• const data = await fetch("https://api.example.com");

• await const data = fetch("https://api.example.com");

• const data = fetch("https://api.example.com").await;

• await fetch("https://api.example.com").then(data => console.log(data));

Which of the following is a correct way to handle an error in an async function?

• Use try...catch inside the function.

• Use .catch() directly after await.

• Errors cannot be handled in an async function.

• Use setTimeout to catch errors.

What does Promise.resolve() do?

• Creates a promise that is automatically rejected.

• Pauses the code until a condition is met.

• Creates a promise that is already resolved with the specified value.

• Returns the status of a promise.

What will the following code output to the console?

function makePizza() {

return new Promise((resolve, reject) => {

setTimeout(() => {

resolve("Pizza is ready");

}, 1000);

});

}

function makeSalad() {

return new Promise((resolve) => {

setTimeout(() => {

resolve("Salad is ready");

}, 500);

});

}

async function prepareDinner() {

const pizza = await makePizza();

const salad = await makeSalad();

console.log(pizza);

console.log(salad);

}

prepareDinner();

• "Pizza is ready" followed by "Salad is ready" after 1 second

• "Salad is ready" followed by "Pizza is ready" after 1.5 seconds

• "Pizza is ready" and "Salad is ready" printed simultaneously after 1 second

• "Salad is ready" followed by "Pizza is ready" after 1 second