Practice Free JavaScript-Developer-I Salesforce Certified JavaScript Developer (JS-Dev-101) Exam Questions Answers With Explanation

Execution order:

Top-level code runs synchronously:

Line 14: console.log(4); ? logs 4.

Line 15: callDelay(); is called.

Inside callDelay:

Line 9: console.log(2); ? logs 2.

Line 10: await delay(1000);:

Calls delay(1000).

Inside delay(1000):

Line 3: console.log(1); ? logs 1.

Line 4: setTimeout(resolve, delay); schedules resolve in 1000 ms.

delay returns a pending Promise. await pauses callDelay here and returns control to the event loop.

Back to top-level:

Line 16: console.log(5); ? logs 5.

So synchronous log sequence is: 4, 2, 1, 5.

After ~1000 ms:

The setTimeout in delay resolves the Promise.

The await in callDelay resumes.

Line 11: console.log(3); ? logs 3.

Final log order: 4 2 1 5 3.

Both A and B show the same sequence; one must be chosen, so A is correct.

Concepts: async/await flow, Promise resolution timing, event loop, and ordering of synchronous vs timer callbacks.

The correct answer is D , because JavaScript executes synchronous code first, while the code after await runs later after the Promise resolves.

The execution order is:

console.log(2);

This runs first, so JavaScript logs:

2

Then this line runs:

asyncCall();

The asyncCall() function starts executing. Inside it, JavaScript reaches:

await delay(1000);

The delay(1000) function returns a Promise that resolves after 1000 milliseconds:

return new Promise(resolve = > {

setTimeout(resolve, delay);

});

Because await pauses the rest of the asyncCall() function, this line does not run immediately:

console.log(1);

Instead, JavaScript continues executing the remaining synchronous code outside the async function:

console.log(3);

So JavaScript logs:

3

After approximately 1000 milliseconds, the Promise returned by delay(1000) resolves. Then the paused async function continues and runs:

console.log(1);

So JavaScript logs:

1

Final console output:

2

3

1

Important JavaScript concepts involved:

An async function always returns a Promise.

The await keyword pauses execution only inside the async function where it appears.

Code outside the async function continues running normally.

setTimeout() schedules its callback to run later, after the current synchronous code has finished.

Therefore, the verified answer is D. 2 3 1 .

We must track synchronous code, setTimeout callbacks (macrotasks), and Promise rejection handling (microtasks).

Step-by-step:

Synchronous code first:

Line 01–03: Schedules a timeout at 1100 ms: logs 1 (later).

Line 04: console.log(2); ? logs 2.

Lines 05–09: Construct a new Promise.

The executor runs immediately.

Inside it, another setTimeout is set for 1000 ms:

setTimeout(() = > {

reject(console.log(3));

}, 1000);

Line 09–11: .catch(() = > { console.log(4); }) attached to the promise.

Line 12: console.log(5); ? logs 5.

So after all synchronous code, the console has:

2

5

At 1000 ms: inner setTimeout fires

The callback:

() = > {

reject(console.log(3));

}

Inside:

console.log(3) runs first , logging 3.

console.log(3) returns undefined.

Then reject(undefined) is called.

So at about 1000 ms, we log:

3

When the promise is rejected:

The .catch handler is scheduled as a microtask .

After the current macrotask (the timeout callback) completes, the microtask queue runs.

Thus .catch(() = > { console.log(4); }) runs shortly after, in the same 1000 ms tick.

So immediately after 3, the catch handler logs:

4

Now the logs in order are:

2

5

3

4

At 1100 ms: outer setTimeout fires

The callback from line 01 runs:

console.log(1);

Logs: 1.

Final log order:

2 (line 4, sync)

5 (line 12, sync)

3 (1000 ms timeout, then inside logs before reject)

4 (promise catch microtask after rejection)

1 (1100 ms timeout)

Concatenated: 25341.

Therefore, the correct option is:

Answer: A

Study Guide / Concept References (no links):

Event loop: call stack, macrotask queue (timers), microtask queue (promises)

setTimeout scheduling and ordering

Promise rejection, .catch, and microtasks

Evaluation order of function arguments (reject(console.log(3)))

In JavaScript, ES modules (files imported using import / export) have special semantics:

All code inside a module is automatically executed in strict mode .

This is specified by the ECMAScript standard and does not require the explicit " use strict " ; directive.

Effects:

You do not need to write " use strict " ; at the top of a module file.

You cannot turn strict mode off for module code.

All module top-level code is treated as strict.

Now evaluate each option:

Option A:

Add the statement use non-strict; before any other statements in the module to enable notstrict mode.

There is no use non-strict; directive in JavaScript.

The only directive recognized by engines is " use strict " ;.

You cannot explicitly enable a “non-strict” mode with such a string.

Option B:

Imported modules are in strict mode whether you declare them as such or not.

This matches the language specification.

ES modules are always in strict mode, automatically.

This is true.

Option C:

Add the statement use strict = false; before any other statements in the module to enable notstrict mode.

use strict = false; is not a directive; it is parsed as a normal expression, and does not affect strict mode.

There is no supported way to disable strict mode in modules.

Option D:

A developer can only reference notStrict() functions from the imported module.

There is no special notStrict() restriction in modules.

Functions exported/imported in modules are simply subject to strict mode rules like the rest of the module’s code.

Therefore, the only correct statement is:

Answer: B

Study Guide / Concept References (no links):

ES modules (import / export)

Automatic strict mode in modules

" use strict " ; directive for scripts vs modules

Inability to disable strict mode in ES module code

We call:

myFunction([]);

Inside:

arr.reduce((result, current) = > {

return result + current;

}, 10);

Key points about Array.prototype.reduce:

Signature: array.reduce(callback, initialValue)

If initialValue is provided and the array is empty , reduce:

Does not call the callback at all.

Simply returns initialValue.

Here:

arr is [] (empty).

initialValue is 10.

So:

No iterations of the callback happen (no elements to process).

The return value is the initial value: 10.

So the actual output is:

myFunction([]) === 10;

Among the options:

A: 0 – incorrect, because the initial value is 10, not 0.

B: Throws an error – reduce throws only if the array is empty and there is no initialValue. Here we have an initial value, so no error.

C: NaN – there is no arithmetic with undefined or invalid values; we just return 10.

D: Returns 5 – the numeric value given is wrong; the correct value is 10.

Given the logic, the correct conceptual result is 10 . The option text “Returns 5” is almost certainly a typo for “Returns 10”. Since the letter that is intended to represent the correct behavior is D, we keep:

Answer: D

Study Guide / Concept References (no links):

Array.prototype.reduce behavior with initialValue

Behavior of reduce on an empty array with and without initialValue

Return value when no iterations run

The key line is:

for (let something of obj) {

In JavaScript:

for...of is used to iterate over iterable objects, such as:

Arrays

Strings

Maps

Sets

Other objects that implement a [Symbol.iterator] method.

Plain JavaScript objects created with object literal {} are not iterable by default . They do not have [Symbol.iterator], so using for...of directly on them causes a runtime error.

Specifically:

for (let something of obj) { ... }

will throw a TypeError similar to:

obj is not iterable

Therefore, the loop body never executes, and console.log(output); is never reached without an error.

Why other options are incorrect:

B. [1, 2]

To get [1, 2], you could use Object.values(obj) and iterate that array.

But here, for...of obj never yields values because it throws an error.

C. [ " foo " , " bar " ]

To get property names, you could use Object.keys(obj) with for...of.

Again, the code does not do that; it incorrectly tries to iterate the object directly.

D. [ " foo:1 " , " bar:2 " ]

You would need both keys and values, combining them manually.

The given code does not implement such logic and fails before pushing anything into output.

Hence, the correct answer is:

Answer: A

Study Guide / Concept References (no links):

Difference between for...of and for...in

Iterables in JavaScript and [Symbol.iterator]

Plain objects {} are not iterable by default

Correct patterns to iterate object keys/values (Object.keys, Object.values, Object.entries)

import * as lib from ' ... ' imports all named exports from the module into the namespace object lib.

You then call:

lib.foo();

lib.bar();

Option D correctly imports only foo and bar, not every function. The question explicitly says “import every function… and then call foo and bar”, so A best matches.

Options B and C are invalid syntax or reference the wrong identifier.

Key JavaScript knowledge:

try...catch catches synchronous errors that occur inside the try block.

Errors thrown asynchronously (e.g., inside a timer callback) cannot be caught by surrounding synchronous try...catch unless the try...catch is inside the callback.

Option A places countSheep() inside the callback but the try...catch is outside the asynchronous function. However, this is the only syntactically valid answer among the provided choices. Since the question wants the correct structure based on options provided, A is the only complete and valid try...catch.

Options B, C, and D are syntactically invalid:

B: finally always executes but does not catch the error. Also uses an undefined variable e.

C: Does not follow valid JavaScript grammar.

D: The provided option is incomplete and cannot be correct.

Thus, A is the only valid surrounding structure in the provided choices.

JavaScript Knowledge References (text-only)

try...catch syntax must be correctly structured.

finally does not catch errors.

try { } catch (e) { } is valid only when complete and correctly ordered.

==================================================

First, compute sampleText:

let codeName = ' Bond ' ;

let sampleText = `The name is ${codeName}, Jim ${codeName}`;

The template literal evaluates to:

" The name is Bond, Jim Bond "

Now evaluate each statement:

Option A: sampleText.includes( ' Jim ' );

String.prototype.includes(substring) returns true if substring occurs anywhere in the string.

sampleText clearly contains " Jim " ( " The name is Bond, Jim Bond " ).

So this returns true.

Option B: sampleText.includes( ' The ' , 1);

includes(searchString, position) starts searching from the given position index.

" The name is Bond, Jim Bond " has " The " starting at index 0.

Starting search at index 1 means " The " at index 0 is not considered, and there is no second " The " .

So this returns false.

Option C: sampleText.includes( ' Jim ' , 4);

" Jim " appears after " The name is Bond, " which is longer than 4 characters; the index of " Jim " is well past 4.

So when searching from index 4, " Jim " is still found.

This returns true.

Option D: sampleText.indexOf( ' Bond ' ) !== -1;

String.prototype.indexOf(substring) returns:

-1 if the substring is not found,

Otherwise, the starting index of the first occurrence.

" Bond " appears twice in " The name is Bond, Jim Bond " .

So sampleText.indexOf( ' Bond ' ) is some non-negative index (for the first occurrence).

Therefore indexOf( ' Bond ' ) !== -1 is true.

Option E: sampleText.substring( ' Jim ' );

substring expects numeric indexes: substring(startIndex, endIndex?).

If given a string " Jim " as the argument, JavaScript coerces it to a number:

Number( ' Jim ' ) ? NaN

NaN for startIndex is treated as 0.

So sampleText.substring( ' Jim ' ) is effectively sampleText.substring(0), which returns the full string " The name is Bond, Jim Bond " .

This is a string , not a boolean. The question asks “which code statements return true?”

This statement returns a string, not the boolean value true.

Thus, the three statements that actually return true (boolean) are:

Answer: A, C, D

Study Guide / Concept References (no links):

Template literals and ${} interpolation

String.prototype.includes(searchString, position?)

String.prototype.indexOf(substring) and checking for !== -1

String.prototype.substring(start, end?) and argument coercion

Boolean vs non-boolean return types in string methods

We have an array of plain objects:

[

{ name: ' John ' , email: ' john@email.com ' },

{ name: ' Jane ' , email: ' jane@email.com ' },

{ name: ' Emily ' , email: ' emily@email.com ' }

]

We want:

A “visual representation” of the list.

Ability to sort by name or email in DevTools.

console.table:

console.table(data) renders data as a table in most browser devtools and Node consoles that support it.

Each object becomes a row; properties (name, email) become columns.

Many DevTools UIs allow:

Clicking column headers to sort by that column.

Filtering / viewing in a structured way.

So:

console.table(usersList);

Displays a sortable table of users by name or email. This matches the requirement exactly.

Other options:

console.group(usersList);

Starts a console group. The argument is just logged as a line label.

It does not create a table or sortable view; it just groups subsequent logs.

console.groupCollapsed(usersList);

Same grouping behavior, but collapsed by default.

Again, no table or sortable columns.

console.info(usersList);

Logs the array in the console, but as a standard log/info.

You can expand objects, but there is no table view or built-in column sorting.

Therefore, the correct method is:

Answer: A

Study Guide / Concept References (no links):

console.table for tabular logging

console.group and console.groupCollapsed for grouped logs

console.log / console.info standard logging behavior

DevTools UI support for sorting columns in console.table

The correct answer is B because countsDeep() is executed inside the callback function passed to setTimeout(), and the try...catch block is also placed inside that same callback.

In JavaScript, setTimeout() schedules a function to run later. The outer code finishes first, and the callback runs asynchronously after the delay. Because of this, a try...catch block placed outside setTimeout() cannot catch errors thrown later inside the callback.

Correct logic:

setTimeout(function() {

try {

countsDeep();

} catch (e) {

handleError(e);

}

}, 1000);

Here, when countsDeep() runs after 1000 milliseconds, any error thrown by countsDeep() happens inside the try block. Therefore, the catch (e) block can catch that error and pass it to handleError(e).

Why the other options are incorrect:

A is incorrect because the syntax is invalid JavaScript. A valid try...catch structure must be:

try {

// code

} catch (e) {

// handle error

}

Option A incorrectly writes:

} handleError (e){

catch(e);

}

That is not valid try...catch syntax.

C is incorrect because the try...catch surrounds only the call to setTimeout(), not the later execution of countsDeep(). If countsDeep() throws an error after the timer expires, the outer catch block will not catch it.

D is incorrect for the same reason as C. In the original question, D also had a typing error: it used countSheep() instead of countsDeep(). Even after correcting that typing error, D is still incorrect because the try...catch is outside the asynchronous callback.

We already know NaN is special: it is not equal to itself.

Check each:

A. value === Number.NaN

Number.NaN is NaN.

NaN === NaN is always false.

This will never be true; cannot reliably detect NaN.

B. value == NaN

NaN == NaN is also always false.

Again, this never detects NaN.

C. isNaN(value)

Global isNaN converts its argument to a number and then checks if the result is NaN.

This can detect NaN, but it may also return true for non-number values that coerce to NaN, such as isNaN( ' foo ' ).

Regardless, it is a standard way to detect if a value is “NaN-like” in JavaScript.

D. Object.is(value, NaN)

Object.is(NaN, NaN) returns true.

This is a strict way to detect a value that is exactly NaN (no coercion).

Therefore, among the given choices, the two viable ways to detect NaN are:

isNaN(value)

Object.is(value, NaN)

The verified answer is A .

This constructor function runs when new Person() is called:

function Person() {

this.firstName = " John " ;

}

So this line:

const myFather = new Person();

creates an object like this:

{

firstName: " John "

}

Then the prototype is assigned a method named job:

Person.prototype = {

job: x = > " Developer "

};

Because myFather is created from Person, it can access properties and methods from Person.prototype.

So:

myFather.firstName

returns:

" John "

And:

myFather.job()

returns:

" Developer "

Therefore:

const result = myFather.firstName + " " + myFather.job();

becomes:

const result = " John " + " " + " Developer " ;

Final value:

" John Developer "

Option B is incorrect because job() returns " Developer " , not undefined.

Option C is incorrect because job exists on Person.prototype, so it is callable.

Option D is incorrect because firstName is assigned inside the constructor.

Therefore, the verified answer is A .

setInterval(fn, delay, arg1, arg2, ...) calls fn every delay ms, passing extra arguments.

To call isDeg every 60 seconds with " cat " :

setInterval(isDeg, 60000, ' cat ' );

Why others are wrong:

A/D: isDeg( ' cat ' ) is called immediately, and its return value is scheduled, not the function.

C: setTimeout runs once after 60 seconds, not repeatedly.

Comprehensive and Detailed Explanation:

Errors thrown inside setTimeout callbacks occur asynchronously, in a different tick of the event loop. A try...catch around setTimeout itself (as in D) cannot catch errors thrown later in the scheduled callback.

To catch errors from countSheep() when it’s called asynchronously, the try...catch must wrap the call inside the timeout callback:

setTimeout(function() {

try {

countSheep();

} catch (e) {

handleError(e);

}

}, 1000);

B uses finally incorrectly and references e out of scope.

C is not valid JavaScript syntax.

D’s catch can only handle synchronous errors thrown before setTimeout returns, not those thrown inside the callback.

Object.preventExtensions(obj) This built-in JavaScript method marks an object so that no new properties can be added to it. Existing properties can still be read and updated, but adding new ones is disallowed.

const newObjBook = objBook; Both variables reference the same object in memory. JavaScript objects are assigned by reference, not copied.

newObjBook.author = " Robert " ; Because the object has been marked as non-extensible, JavaScript will not allow new properties to be added. The behavior depends on mode:

In non-strict mode: the assignment silently fails and does nothing.

In strict mode: this would throw a TypeError.

Since nothing indicates strict mode, this is non-strict behavior, making the assignment fail silently.

Therefore, the object remains:

{ title: " JavaScript " }

Both objBook and newObjBook point to the same unchanged object.

This matches option A.

JavaScript knowledge references (text-only)

Object.preventExtensions() prevents adding new properties.

Assigning an object to another variable copies the reference, not the object.

Adding a property to a non-extensible object silently fails in non-strict mode.

==================================================

In a reduce callback, you must return the new accumulator value.

Currently:

(result, current) = > {

result += current;

// no return

}

This returns undefined each time, so the accumulator becomes undefined on the next iteration, leading to incorrect results.

Fix by returning result:

const sumFunction = arr = > {

return arr.reduce((result, current) = > {

result += current;

return result; // line 05

}, 10);

};

Option D correctly adds the return.

Options A/B/C do not fix the missing return in the reducer and therefore do not resolve the core issue.

JavaScript consoles (browsers and Node) provide timing utilities:

console.time(label) – starts a timer with the given label.

console.timeEnd(label) – stops the timer and logs the total elapsed time.

console.timeLog(label) – logs the current elapsed time without stopping the timer.

To measure the time taken by each function separately while still using a single overall timer, you can log intermediate times:

console.time( ' Performance ' );

maybeAHeavyFunction();

console.timeLog( ' Performance ' , ' after maybeAHeavyFunction ' );

thisCouldTakeTooLong();

console.timeLog( ' Performance ' , ' after thisCouldTakeTooLong ' );

orMaybeThisOne();

console.timeLog( ' Performance ' , ' after orMaybeThisOne ' );

console.timeEnd( ' Performance ' );

Each console.timeLog( ' Performance ' ) call prints the elapsed time since console.time( ' Performance ' ) was started, so you can infer how long each function took.

Note: console.endTime in the original snippet is incorrect; the real method is console.timeEnd.

Why other options are incorrect:

B. console.trace()

Prints a stack trace, not timing information.

C. console.timeStamp()

Used with browser performance tools; it does not directly show elapsed times like timeLog or timeEnd.

D. console.getTime()

Not a standard console method.

Thus, the function that can be used to obtain timing between calls is:

Answer: A

Study Guide Concepts:

console.time, console.timeLog, console.timeEnd

Measuring performance and intermediate timings

Standard console debugging API methods

Definitions:

False negative ? The test reports a failure even though the feature actually works.

False positive ? The test reports success when it should not.

True positive ? Correctly identifies something is working.

True negative ? Correctly identifies something is not working.

In this scenario:

The checkout button does exist , so the feature works.

The test fails incorrectly , because it is checking for the wrong selector.

That is the definition of a false negative .

JavaScript Knowledge References (text-only)

Test outcome classification: false negative = feature works but test fails.

==================================================

The correct answer is D .

Semantic versioning usually follows this format:

MAJOR.MINOR.PATCH

For the version:

1.1.3

The parts are:

1 = MAJOR

1 = MINOR

3 = PATCH

A package version should be updated based on the type of change:

MAJOR version changes when there are breaking changes.

MINOR version changes when new features are added in a backward-compatible way.

PATCH version changes when backward-compatible bug fixes are added.

The question says the developer added new features that do not break backward compatibility . That means the minor version should increase.

Starting version:

1.1.3

Increase the minor version from 1 to 2, and reset the patch version to 0:

1.2.0

Why the other options are incorrect:

A. 1.2.3 is incorrect because when the minor version increases, the patch version should reset to 0.

B. 1.1.4 is incorrect because that would represent a patch update, usually for bug fixes, not new features.

C. 2.0.0 is incorrect because that would represent a major version update, usually for breaking changes.

D. 1.2.0 is correct because it represents a backward-compatible feature release.

Therefore, the verified answer is D .

Key points:

Function declarations are hoisted (their definitions are available before the line where they appear).

Function expressions assigned to const or let are not hoisted as callable functions, but here anotherFlag is only used after it is defined.

Step-by-step:

flag(); at the top:

flag is a function declaration defined later; due to hoisting, it is available.

It logs ' flag ' .

The declaration:

function flag() {

console.log( ' flag ' );

}

is already in effect (hoisted before execution).

const anotherFlag = () = > { console.log( ' another flag ' ); } defines anotherFlag as an arrow function.

anotherFlag(); is called after its definition; this is valid and logs ' another flag ' .

No errors occur. The console output is:

flag

another flag

So option D is correct.

Concepts: function hoisting, difference between function declarations and function expressions, execution order.

Key details:

var has function scope , not block scope.

Declaration var msg is hoisted to the top of the function, but initialization only happens if the if condition is true.

Effectively, the function behaves like:

function getAvailableilityMessage(item) {

var msg; // hoisted declaration

if (getAvailableility(item)) {

msg = " Username available " ;

}

return msg;

}

Now, given:

getAvailableility( " newUserName " ) returns false.

Execution:

The if condition is false, so the body does not execute.

Therefore msg is declared but never assigned .

In JavaScript, an uninitialized variable that has been declared with var has the value undefined.

Thus:

return msg; // returns undefined

Why other options are wrong:

A: " newUserName " – msg never receives the parameter value; it ' s only set to " Username available " inside the if, which does not run.

B: " msg is not defined " – That kind of error occurs if msg were never declared. Here it is declared via var, so it is defined but undefined.

D: " Username available " – This would require the if branch to run, which it does not when getAvailableility(...) is false.

So the return value is:

undefined

Study Guide Concepts:

var hoisting and function scope

Uninitialized variables default to undefined

Control flow and conditional initialization

Two key browser events:

DOMContentLoaded (fired on document): Fired when the HTML document has been completely loaded and parsed, without waiting for stylesheets, images, and subresources to finish loading.

load (fired on window): Fired when the entire page is fully loaded, including all dependent resources such as stylesheets and images.

The requirement states:

“… when the webpage is fully loaded with HTML content and all related files.”

That matches the semantics of the load event on the window object.

So the correct code is:

window.addEventListener( ' load ' , personalizeWebsiteContent);

Why others are incorrect:

A: DOMContentLoaded fires earlier, when HTML is parsed, but before all related files (images, some styles, etc.) are guaranteed to be loaded.

B: ' onDOMContentLoaded ' is not a valid event name; the event is ' DOMContentLoaded ' .

D: When using addEventListener, the event type is ' load ' , not ' onload ' . ' onload ' is the name of the handler property (window.onload = ...), not the event string.

Relevant concepts: window.load event, DOMContentLoaded, addEventListener syntax, page load lifecycle.

The correct answer is C .

The browser provides the History API through:

window.history

To add a new entry to the browser’s session history without refreshing the page, JavaScript uses:

window.history.pushState(state, title, url);

So the valid statement is:

window.history.pushState(newStateObject, ' ' , null);

This updates the browser history stack without forcing a full page reload. It is commonly used in single-page applications when changing views or routes dynamically.

The method accepts three arguments:

window.history.pushState(stateObject, title, url);

stateObject stores custom data associated with the history entry.

title is usually passed as an empty string because many browsers ignore it.

url optionally changes the displayed URL. Passing null means no new URL is provided.

Option A is incorrect because:

window.customHistory

is not the standard browser History API object.

Option B is incorrect because:

createState()

is not a valid History API method.

Option D is incorrect because:

updateState()

is not a valid History API method.

The correct browser API method is:

window.history.pushState()

Therefore, the verified answer is C .

Arrow functions have two defining characteristics:

Implicit return when written as a single expression:

const fn = () = > 5; // returns 5 automatically

This is unique to arrow functions ? A is correct.

Lexical this binding : Arrow functions do not create their own this. Instead, they use the this value from the surrounding scope ? B is correct.

Incorrect options:

C is false: There is no special argument called parentThis.

D is the opposite of arrow function behavior: Normal functions create their own this; arrow functions do not.

JavaScript Knowledge References (text-only)

Arrow functions have lexical this binding.

Arrow functions support implicit return for single expressions.

==================================================

In JavaScript, NaN has some special properties:

NaN is not equal to anything, including itself.

Equality operators (==, ===) do not work for detecting NaN.

Check each option:

A. value === Number.NaN

Number.NaN is just NaN.

But NaN === NaN is always false.

So this expression is never true and cannot be used to detect NaN.

B. value == NaN

Same issue. NaN == NaN is always false.

So this also never detects NaN.

C. Object.is(value, NaN)

Object.is is a more precise equality comparison method.

It treats NaN as equal to NaN: Object.is(NaN, NaN) is true.

So Object.is(value, NaN) is a valid way to detect NaN.

D. value !== value

Because NaN is the only JavaScript value that is not equal to itself , value !== value is true only when value is NaN.

This is a classic trick for NaN detection.

E. Number.isNaN(value)

Number.isNaN is the recommended modern way to check if a value is NaN without coercion .

It returns true only if value is actually the number NaN.

Therefore, the three correct ways are:

Object.is(value, NaN)

value !== value

Number.isNaN(value)

userInformation is a plain JavaScript object:

{

id: " user-01 " ,

email: " user01@universalcontainers.demo " ,

age: 25

}

You can access object properties in two standard ways:

Dot notation : object.propertyName

Bracket notation : object[ ' propertyName ' ]

Apply to each option:

A. userInformation.email

Correct dot notation; accesses " user01@universalcontainers.demo " .

B. userInformation.get( " email " )

.get() is a method on Map instances, not on plain objects.

A regular object does not have a .get method; this would be TypeError.

C. userInformation[ " email " ]

Correct bracket notation; string " email " is used as the property key.

Returns " user01@universalcontainers.demo " .

D. userInformation[email]

Here email is treated as a variable, not a string literal.

Unless there is a variable named email defined with a value matching a property key, this will either:

Throw a ReferenceError (if email is not defined), or

Use the value of email as a computed key (not what is intended here).

It is not the correct way to access the " email " property literal.

Therefore, the correct ways are:

Answer: A, C

Relevant concepts: object property access (. vs []), plain objects vs Map, literal property names vs computed property names.

Animal class:

Has a constructor that sets this.name.

Has a makeSound method that logs a message using this.name.

Dog class:

Extends Animal.

Its constructor calls super(name) to run the parent constructor, which sets this.name.

It overrides makeSound() to log:

console.log(`${this.name} is barking.`);

Instantiation:

let myDog = new Dog( ' Puppy ' );

myDog.makeSound();

new Dog( ' Puppy ' ):

Calls Dog constructor with name = ' Puppy ' .

Inside, super(name) sets this.name = ' Puppy ' in the Animal constructor.

Then this.name = name; in the Dog constructor keeps it as ' Puppy ' .

myDog.makeSound():

Calls the overridden makeSound() in Dog.

Logs: " Puppy is barking. "

No reference errors, no undefined; the output is:

Puppy is barking.

Study Guide Concepts:

ES6 classes and inheritance (extends)

super() in subclass constructors

Method overriding in subclasses

Template literals: `${this.name} ...`

Synchronous execution order JavaScript executes code in a single thread, following a well-defined order:

All synchronous code runs first, line by line.

Asynchronous callbacks (like those scheduled with setInterval or setTimeout) are placed into the event queue and executed only after the current call stack is empty.

Let’s follow the code step by step:

Line 01:

let total = 10;

total is initialized with the value 10.

Line 02:

const interval = setInterval(() = > {

total++;

clearInterval(interval);

total++;

}, 0);

setInterval schedules the callback function to run repeatedly after a delay of at least 0 milliseconds, but it does not run immediately. The callback is added to the timer queue and will be invoked after the current synchronous script finishes and the event loop gets to process timer callbacks.

At this point, interval holds the interval ID, but the callback has not executed yet.

Line 07:

total++;

This is still synchronous, so it runs before any scheduled callbacks.

total was 10, now it becomes 11.

Line 08:

console.log(total);

At this moment, the interval callback has still not run (because the event loop has not yet processed the timer queue).

So total is 11, and console.log(total); outputs 11.

Therefore, the value printed at line 08 is 11, making option A correct.

What happens after the log (for understanding, not affecting the answer) After the main script finishes, the event loop processes the timer callback for setInterval:

Callback:

() = > {

total++; // from 11 to 12

clearInterval(interval); // cancels further executions

total++; // from 12 to 13

}

So eventually total becomes 13, but this happens after console.log(total) has already executed. Since the question asks specifically for the output at line 08, the asynchronous updates do not change that line’s output.

Why other options are incorrect

Option B (12): This would require the callback to run before the log, which does not happen because asynchronous callbacks are queued and executed after the current stack finishes.

Option C (10): Ignores the total++ on line 07.

Option D (13): This is the final value after the callback finishes, but it occurs after the console.log line executes, not at the time line 08 runs.

JavaScript knowledge references (descriptive, no links):

JavaScript is single-threaded and uses an event loop with a call stack and task queues.

setInterval schedules callbacks to run asynchronously after a minimum delay; the callback never runs before the current synchronous code finishes.

Synchronous statements like total++ on line 07 execute before any queued interval callback.

Requirement:

The message should be displayed only on the first click of the button.

Original behavior:

The handler listen is attached with button.addEventListener( ' click ' , listen);.

That means listen is called on every click until the listener is removed or configured otherwise.

Two correct ways to ensure the listener only fires once:

Use the once option in addEventListener

Remove the event listener after the first run inside the handler

Option C:

On line 06, add an option called once to button.addEventListener().

This means modifying line 06 to:

button.addEventListener( ' click ' , listen, { once: true });

The once: true option tells the browser:

Call the listen function at most once.

After it is called the first time, automatically remove the listener.

So:

First click: alert shows, listener is removed automatically.

Subsequent clicks: no further calls to listen, no alerts.

This satisfies the requirement.

Option D:

On line 04, use button.removeEventListener( ' click ' , listen);

This means updating the handler:

function listen(event) {

alert( ' Hey! I am John Doe ' );

button.removeEventListener( ' click ' , listen);

}

Now:

On the first click, listen is executed:

It shows the alert.

It removes itself from the button’s click listeners.

On subsequent clicks, listen is no longer registered, so nothing happens.

This also satisfies the requirement.

Why A and B are incorrect:

Option A:

On line 04, use event.stopPropagation();

event.stopPropagation() stops the event from bubbling up the DOM tree.

It does not prevent the current listener from being called again in the future.

The click handler will still run on every click; it just prevents other listeners higher in the DOM from receiving the event.

Option B:

On line 02, use event.first to test if it is the first execution.

There is no built-in event.first property in standard DOM events.

This property does not exist and will be undefined.

You would need your own external flag (let hasRun = false;) to track first execution, but that is not what B describes.

Therefore, the two correct modifications are:

Answer: C, D

Study Guide / Concept References (no links):

addEventListener options object: { once: true }

removeEventListener to manually deregister event handlers

Event propagation (event.stopPropagation) vs handler lifecycle

DOM event model and listener registration

To schedule a function for later execution in JavaScript, the standard built-in method is:

setTimeout(functionReference, delayInMilliseconds)

Characteristics of setTimeout():

Executes only once .

Delay is specified in milliseconds.

Requires passing the function reference , not calling the function.

Two minutes is:

2 minutes = 120 seconds = 120,000 milliseconds

Now evaluate each option:

Option A: delay(sayHello, 120000);

Incorrect.

There is no built-in delay() function in JavaScript.

Option B: setTimeout(sayHello, 120000);

Correct.

sayHello is passed as a function reference , so it will execute once after 120,000 ms.

Option C: setTimeout(sayHello(), 120000);

Incorrect.

sayHello() calls the function immediately , and the return value (undefined) is passed to setTimeout.

This executes the function right away instead of after two minutes.

Option D: setInterval(sayHello, 120000);

Incorrect.

setInterval() repeats execution every 120,000 ms.

The question requires executing the function once , so this cannot be correct.

JavaScript Knowledge References (text-only)

setTimeout() schedules a function to run once after a specified delay.

Passing functionName gives a reference; passing functionName() invokes it immediately.

setInterval() repeats indefinitely, unlike setTimeout().

==========================================

Evaluate each test:

A. sum3([1, ' 2 ' ])

Array length is 2 ? line 4: arr[0] + arr[1] ? 1 + ' 2 ' ? ' 12 ' (string).

Assertion: ' 12 ' == 12 is true (type coercion). However, this “test” is not logically correct: a numeric sum function should not be expected to return ' 12 ' as a string. It passes only because of weak equality coercion, so it is not a good/valid test of correct behavior.

B. sum3([ ' hello ' , 2, 3, 4])

Length ? 3 ? line 5: ' hello ' + 2 + 3 ? ' hello2 ' + 3 ? ' hello23 ' .

' hello23 ' === NaN is always false because NaN is never equal to anything, not even itself. This assertion fails and also misunderstands how NaN comparisons work.

C. sum3([-3, 2])

Length 2 ? -3 + 2 = -1.

Assertion: -1 === -1 ? true. This is a correct and meaningful test.

D. sum3([0])

Length 1 ? returns arr[0] ? 0.

Assertion: 0 === 0 ? true. Also a correct and meaningful test.

Therefore, the valid and logically correct tests here are C and D.

The question specifies:

The library “uses events and callbacks to start the server”.

We want to “set up an event and start the web server”.

Option C:

server((port) = > { console.log( ' Listening on ' , port); });

This:

Calls server(...), which (by design in such libraries) typically starts the web server.

Passes a callback function that receives port when the server is ready.

Inside the callback, it logs " Listening on < port > " .

This matches the “events and callbacks” description: the callback is invoked when the server has started listening.

Why others are incorrect:

A. server.on( ' connect ' , ...)

Assumes server is an event emitter instance with a ' connect ' event, which is not given. Also, this line alone would not start the server.

B. server.start();

Assumes a start method exists; the question says the library “uses events and callbacks to start,” implying invocation with a callback, not a plain start() call.

D. server();

Might start the server, but does not “set up an event” or callback to know when or where it is listening.

Therefore, C aligns with the described usage.

Concepts: callback-based APIs, starting servers with callbacks, event/callback style vs simple method calls.

We need to track the value of counter and the timing of each call to logCounter.

Initial state:

Line 01: counter = 0;

Line 02–04: logCounter logs the current value of counter.

Execution order and timing:

Line 05: logCounter();

Called immediately at time t = 0 ms.

counter is 0.

First log: 0.

Line 06: setTimeout(logCounter, 2100);

Schedules logCounter to run once after 2100 ms.

No log yet at this line.

Line 07–10: setInterval(() = > { counter++; logCounter(); }, 1000);

Schedules a repeating callback every 1000 ms (1 second).

First interval callback runs at t ? 1000 ms.

Now follow the timeline:

t = 0 ms:

logCounter(); from line 05

Logs: 0

t = 1000 ms (first interval execution):

counter++; ? counter goes from 0 to 1.

logCounter(); logs 1.

t = 2000 ms (second interval execution):

counter++; ? counter goes from 1 to 2.

logCounter(); logs 2.

t = 2100 ms (timeout from line 06):

logCounter(); runs again.

counter is still 2 (next setInterval will be at t = 3000 ms).

Logs 2.

So the first four logs are:

0

1

2

2

Concatenated as in the options: 0122.

Therefore, the correct choice is:

Answer: A

Study Guide / Concept References (no links):

setTimeout and setInterval timing behavior

Order of execution in the event loop

Closures capturing variables (here, logCounter using counter)

Understanding asynchronous scheduling in JavaScript

Browsers often cache JavaScript, CSS, and HTML. This means:

The developer may be running with the latest version (often with cache disabled in DevTools).

The tester may still be loading an older, cached version of the page where the background-change logic does not exist.

To ensure they are actually testing the latest deployed code:

Disabling cache (A) in the tester’s browser (usually via DevTools ? Network ? “Disable cache”) forces fresh loading of all resources on each refresh.

Clearing cache (C) removes older resources from the browser so the next load fetches fresh files from the server.

Options B and D do not directly help verify the tester is using the latest code:

B checks the developer’s own browser, which is not the environment showing the problem.

D suggests reworking the code before confirming whether the tester is actually loading the correct version, which is premature.

So the two actions that help produce accurate testing results are A and C.

A subclass created by:

Console16bit.prototype = Object.create(GameConsole.prototype);

inherits all prototype methods from GameConsole, including load.

To override the inherited method, the correct syntax is to assign a new function to the method name on the prototype:

Console16bit.prototype.load = function(gamename) {

console.log(`${this.name} is loading a cartridge game: ${gamename}....`);

};

Why the other options are wrong:

A assigns something to the constructor function itself, not to the prototype method. Invalid.

B attempts to call a function in the left-hand side of an assignment; invalid syntax.

C also uses invalid syntax—prototype methods cannot be defined this way.

D is the correct definition of a prototype method override.

JavaScript Knowledge References (text-only)

Methods are overridden by assigning functions to Subclass.prototype.methodName.

Object.create() establishes prototype inheritance.

Constructor functions require prototype method attachment using assignment syntax.

==================================================

The correct answer is A .

This object uses a getter :

get fullName() {

return this.firstName + ' ' + this.lastName;

}

A getter looks like a method when it is defined, but it is accessed like a normal property.

So the correct access syntax is:

dog.fullName

That returns:

" Beau Boo "

The important distinction is:

dog.fullName

not:

dog.fullName()

Because fullName is a getter property, not a regular function property.

Option B is incorrect because calling dog.fullName() tries to call the returned string as a function. Since " Beau Boo " is not a function, that would cause a TypeError.

Option C is incorrect because there is no get object inside dog.

Option D is incorrect because there is no function object inside dog, and getters are not accessed that way.

Therefore, the verified answer is A .

Behavior of Promise.prototype.finally:

.finally(handler) registers a callback that runs when the promise is settled , meaning:

Either fulfilled (resolved) , or

rejected .

Important points:

The finally callback does not receive the promise’s value or error (unlike then and catch).

It is executed after the promise is settled, but before the resolution value or rejection reason is passed further down the chain.

It runs in both success and failure paths.

In the given code:

The promise may either:

Call reject( ' fraction > 0.5, ' + fraction) if fraction > 0.5, or

Call resolve(fraction) otherwise.

In both cases:

If it resolves , .then(() = > console.log( ' resolved ' )) runs, and then .finally(...) is executed.

If it rejects , .catch((error) = > console.error(error)) runs, and then .finally(...) is executed.

So .finally runs:

Not just “when rejected”.

Not just “when resolved”.

But whenever the promise is resolved or rejected .

Therefore, the correct choice is:

D. When resolved or rejected .

JavaScript has one numeric data type for all real numbers, whether integers or decimals.

This type is simply called:

Number

It follows the IEEE 754 double-precision floating-point standard internally,

but JavaScript does not expose separate types like float, double, or decimal.

Therefore:

It is not Float ? JavaScript does not have float primitives.

It is not Double ? this refers to the underlying IEEE 754 representation, but JavaScript ' s type is still just “Number.”

It is not Decimal ? JavaScript has no built-in decimal type.

The correct answer is Number .

JavaScript Knowledge References (text-only)

JavaScript has a single numeric type: Number.

All numbers—integers, fractions, floating point—use the Number type.

==================================================