JavaScript-Developer-I Practice Test Questions

Explanation:

The function declares x with let and y with var, both initialized to 1. When reassign is true, the if-block creates a new block-scoped x set to 2, while the var y redeclaration affects the function scope, updating y to 2. Inside the block, console.log(x) prints 2 (inner x), and console.log(y) prints 2 (function-scoped y). After the block, the inner x is discarded so the outer x remains 1, but y stays 2. Therefore, it logs: 2 2 1 2. This illustrates scoping differences critical for writing efficient predictable JavaScript code.

Explanation:

The console.timeLog() method lets developers record and display intermediate timestamps for named timers started with console.time(). In this scenario, you can insert

console.timeLog('Performance');

immediately after each of the three function calls. Each call will print the elapsed time since console.time('Performance') began, without stopping the timer. Unlike console.timeEnd(), which stops and logs the final duration, console.timeLog() preserves the timer, allowing you to capture multiple checkpoints. Placing console.timeLog() after each function pinpoints individual bottlenecks, making it easier to optimize landing-page performance.

Explanation:

The first promise to settle is car2, which resolves after 1.5 seconds with the string "Car 2 completed". Since Promise.race() returns the value of the first promise that either fulfills or rejects, the .then block receives "Car 2 completed". Appending " the race." yields:

result = "Car 2 completed the race.";

Neither car1 (which rejects after 2 seconds) nor car3 (which resolves after 3 seconds) can win the race. This pattern is useful for timeouts or competing async tasks where you only care about the quickest outcome.

Explanation:

You need to create a FileReader instance to handle file input and then generate a temporary URL for the selected file so the browser can display it. At line 04 you write:
const reader = new FileReader();
This gives you a reader that can process file blobs. Then at line 08 you check for a file and generate an object URL:
if (file) preview.src = URL.createObjectURL(file);
URL.createObjectURL(file) creates a blob URL pointing to the user’s local file, which you assign directly to the ’s src. This pattern is efficient and widely supported for image previews.

Explanation:

Three reliable methods to detect NaN are:
1. Object.is(value, NaN)
2. value !== value
3. Number.isNaN(value)

Because NaN is the only JavaScript value that is not equal to itself, value !== value uniquely identifies it. Object.is() correctly treats NaN as equal to itself, unlike ===, so Object.is(value, NaN) returns true only when value is NaN. Finally, Number.isNaN(value) is the standard built-in that returns true only for genuine NaN, avoiding the pitfalls of the global isNaN. The global isNaN remains unreliable. Prefer Number.isNaN for clarity.

Explanation:

You can import all exports under a namespace alias and then call the functions on that alias:
import * as lib from '/path/universalContainersLib.js';
lib.foo();
lib.bar();

This uses the ES6 namespace import syntax (import * as alias from '…'), bundling every named export from the module into the lib object.

Explanation:

When execution is paused at a breakpoint, the DevTools Console (and Scope pane) lets you inspect all in-scope variables—so you can see the current values of carSpeed and fourWheels (A). You also get a live reference to any DOM element you’ve queried (here, the ), allowing you to explore its .style, event listeners, attributes, etc. (C).

You won’t automatically see a count of how many Car instances exist (that’d require custom bookkeeping), nor is window.localStorage shown by default in the paused-scope view—though you could manually inspect it in the Console.

Explanation:

White box testing involves knowledge of the internal implementation. Verifying how many times database.query is called and with what arguments requires insight into the code’s inner workings, fitting a white-box approach.

Mocking replaces real dependencies with controllable fakes that record interactions. By mocking database.query, you can inspect call counts and arguments, satisfying the requirement to track each invocation.

Integration tests (A) focus on end-to-end behavior without inspecting internal calls, and black-box tests (B) treat the system as an opaque unit, so neither applies here.

Explanation:

The implementation in option B works because it explicitly declares foo and bar as named exports—using
export { foo, bar };
—which aligns perfectly with the import statement
import { foo, bar } from '/path/Utils.js';
so both functions are brought into scope by name. In option C, the module exports a default anonymous class whose instances provide foo and bar methods. While this does expose those methods, you cannot import them directly with named-import syntax; instead you’d write
import Utils from '/path/Utils.js';
const { foo, bar } = new Utils();
so although the class does bundle foo and bar, it does not satisfy the original import { foo, bar } form without additional steps.

Explanation:

1. Immediate call (logCounter()): prints the initial counter value of 0.

2. At 1000 ms, the setInterval callback fires: it increments counter to 1 then logs it.

3. At 1100 ms, the setTimeout callback runs next—it just logs counter, which is still 1 (no further increments have occurred).

4. At 2000 ms, the second setInterval tick increments counter to 2 and logs it.

So you see 0, then 1, then 1 again, then 2.