Intermediate JavaScript test (Intermediate)

Sample questions

5 sample questions from the Intermediate JavaScript test, with the answers. Samples are taken out of the live test, so you will not meet these when you sit it.

1. Which of the following correctly describes the behavior of Promise.all() when handling multiple promises in a project scenario?

   1. The Promise.all() method continues processing even if one promise is rejected, and only rejects if all promises are rejected.
   2. The Promise.all() method waits for all promises to resolve before proceeding, and if any promise is rejected, it immediately rejects with that error.
   3. The Promise.all() method resolves immediately if any promise is resolved, regardless of other promises.
   4. The Promise.all() method ignores any rejected promises and only considers resolved ones.

   Answer: B. The Promise.all() method waits for all promises to resolve before proceeding, and if any promise is rejected, it immediately rejects with that error.

   Promise.all() is designed to handle multiple promises at once. It only resolves when all promises in the iterable have resolved successfully. If any of the promises is rejected, it immediately rejects with that error, without waiting for the other promises to resolve. This makes it useful for scenarios where all asynchronous operations must complete successfully for the overall operation to succeed.

2. Consider the following code: <br><br><button id='myButton'>1</button><br><script>const button = document.getElementById('myButton');button.value = '3';button.addEventListener('click', function() { setTimeout(() => { console.log(this.value); }, 1000); });</script><br><br>What will the code log after the button is clicked and the timeout completes?

   1. The function will throw an error.
   2. The function will log '3' after the timeout completes.
   3. The function will log '1' after the timeout completes.
   4. The function will log 'undefined' after the timeout completes.

   Answer: B. The function will log '3' after the timeout completes.

   In JavaScript, when a function is used as an event handler, the value of 'this' inside the function refers to the element that triggered the event, not the outer scope. In this case, the 'this' inside the timeout callback refers to the button element, and 'this.value' correctly retrieves the value of the button, which is '3'.

3. Consider the following code: function createFunctions() { const result = []; for (var i = 0; i < 5; i++) { result.push(function() { console.log(i); }); } return result; } const functions = createFunctions(); functions.forEach(func => func()); What will be the output of this code?

   1. The function will log 5, 5, 5, 5, 5.
   2. The function will log an error.
   3. The function will log 1, 2, 3, 4, 5.
   4. The function will log 0, 1, 2, 3, 4.

   Answer: A. The function will log 5, 5, 5, 5, 5.

   The closure captures the variable 'i' by reference, not by value. Since the loop completes before any of the functions are executed, all functions refer to the final value of 'i', which is 5.

4. Consider the following code snippet: function createFunctions() { let results = []; for (let i = 0; i < 3; i++) { results.push(function () { console.log(i); }); } return results; } let functions = createFunctions(); functions[0](); functions[1](); functions[2](); What will be the output of this code?

   1. The function will log 3, 3, 3
   2. The function will not execute because of a syntax error
   3. The function will log 1, 2, 3
   4. The function will log 0, 1, 2

   Answer: A. The function will log 3, 3, 3

   In JavaScript, closures capture variables by reference, not by value. When the loop runs, the variable 'i' is updated, and all the functions created in the loop share the same 'i' variable. As a result, when the functions are executed after the loop completes, they all log the final value of 'i', which is 3.

5. Consider the following code: `for (let i = 0; i < 3; i++) { const f = () => console.log(i); } f();`. What will happen when the function `f` is called after the loop completes?

   1. The function `f` will be redeclared in each iteration, and the closure will capture the same value of `i` for all iterations due to the `let` declaration.
   2. The function `f` will be redeclared in each iteration, but the closure will not capture any value of `i` due to the `let` declaration.
   3. The function `f` will be redeclared in each iteration, but the closure will capture the initial value of `i` due to the `let` declaration.
   4. The function `f` will be redeclared in each iteration, but the closure will capture the latest value of `i` due to the `let` declaration.

   Answer: D. The function `f` will be redeclared in each iteration, but the closure will capture the latest value of `i` due to the `let` declaration.

   In the loop, `let i` creates a new binding for `i` in each iteration. The closure inside the function `f` captures the current value of `i` for each iteration. Even though the function is redeclared in each iteration, the closure correctly captures the latest value of `i` due to the block-scoped `let` declaration. The `var` declaration would have resulted in all closures sharing the same `i`, leading to all functions logging `3`.