JavaScript-Developer-I Salesforce Certified JavaScript Developer (JS-Dev-101) Questions and Answers

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 .

The function:

async function functionUnderTest(isOK) {

if (isOK) return ' OK ' ;

throw new Error( ' not OK ' );

}

Behavior:

If isOK is true:

The function resolves (fulfills the promise) with value ' OK ' .

If isOK is false:

The function throws, which in an async function becomes a rejected promise with Error( ' not OK ' ).

We want an assertion that accurately tests the successful path for isOK === true.

Key points about console.assert:

Signature: console.assert(condition, message?)

If condition is falsy , it logs message as an assertion failure.

If condition is truthy , nothing is logged.

We also must understand await:

await functionUnderTest(true) will resolve to the string ' OK ' .

Now evaluate options.

Option A:

console.assert(await functionUnderTest(true), ' OK ' );

await functionUnderTest(true) → ' OK ' (truthy).

console.assert( ' OK ' , ' OK ' );

Condition is ' OK ' (truthy), so assertion passes.

The message ' OK ' is only shown if the condition is falsy, which it is not.

This correctly verifies that the promise resolved (i.e., did not reject). Among the given options, this is the only one that both:

Uses await properly on the async function, and

Associates the message with the expected success " OK " .

Option B:

console.assert(await (functionUnderTest(true), ' not OK ' ));

Inside the parentheses, the comma operator (a, b) evaluates a, discards it, and returns b.

So (functionUnderTest(true), ' not OK ' ):

Calls functionUnderTest(true) (returns a promise, but its result is discarded),

The expression evaluates to the string ' not OK ' .

Then await ' not OK ' just resolves to ' not OK ' immediately (not a promise).

console.assert( ' not OK ' );

Condition is ' not OK ' (truthy), so the assertion passes regardless of what functionUnderTest actually does.

This does not meaningfully test the function and is misleading.

Option C:

console.assert(functionUnderTest(true), ' OK ' );

functionUnderTest(true) returns a Promise , not the string ' OK ' directly.

A Promise object is always truthy.

So console.assert(promise, ' OK ' ) will pass, even if the promise later rejects.

Also, there is no await, so we are not actually waiting for the async result.

This is not a correct way to assert on an async function’s resolved value.

Option D:

console.assert(await functionUnderTest(true), ' not OK ' );

await functionUnderTest(true) still resolves to ' OK ' (truthy).

console.assert( ' OK ' , ' not OK ' ); passes.

However, the message ' not OK ' is the opposite of what we expect for the success case and is only used when the condition fails.

This makes the assertion logically inconsistent with the function behavior (it would show " not OK " if the assertion failed).

Therefore, the only assertion that:

Properly waits on the async function, and

Has expectation text that matches the successful behavior ( ' OK ' )

is:

Answer: A

Study Guide / Concept References (no links):

async and await behavior in JavaScript

Promises resolving vs rejecting in async functions

console.assert(condition, message) usage

Truthy and falsy values in JavaScript

Comma operator (a, b) semantics

The answer choices appear to belong to an event propagation question using nested elements such as an outer element and an inner element.

The important clue is this third argument:

addEventListener( ' click ' , handlerFunction, true);

When the third argument is true, the event listener runs during the capturing phase .

In event capturing, the browser handles the event from the outside toward the inside:

Outer element → Inner element

So, if an inner element is clicked and both the outer and inner elements have click listeners registered with capture mode set to true, the outer listener runs first, then the inner listener runs.

That produces:

Outer message

Inner message

So the matching option is B .

Important correction:

In the exact code shown, the buttons are sibling elements:

< button class= " secondary " > Save draft < /button >

< button class= " primary " > Save and close < /button >

They are not nested inside one another. Therefore, with the code exactly as written:

Clicking the secondary button logs:

Save message.

Clicking the primary button logs:

Success message.

However, because the provided answer choices refer to Outer message and Inner message , the intended concept is clearly event capturing. In a capturing-phase question with nested outer and inner elements, the correct order is:

Outer message

Inner message

Therefore, the verified answer for the intended event-capturing question is B .

Key JavaScript Promise rule:

try...catch does not catch asynchronous errors that occur in Promise chains.

Therefore, the correct way to handle errors in a Promise is:

promise.then(...).catch(...);

Analysis of options:

A and B: Both wrap asynchronous code in try...catch, which does not catch Promise rejections. try...catch only catches errors thrown synchronously inside the block.

C: Correct. A .catch() on the Promise chain handles any error from the Promise returned by requestPromise().

D: .finally() executes regardless of success or failure, but it does not receive the error object , so it cannot handle the error.

Thus the only valid solution is option C .

JavaScript Knowledge References (text-only)

Promise rejections must be handled with .catch().

try...catch only handles synchronous code.

.finally() does not receive a rejection reason.

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

console.log() in browser-side JavaScript writes output to the browser’s JavaScript console , which is available in the browser’s Developer Tools.

In a typical browser (Chrome, Firefox, Edge, etc.), you open DevTools and go to the Console tab.

Any console.log( " Page has loaded! " ); executed in page JavaScript will appear there.

Why A is correct:

The function onLoad is a client-side function (runs in the browser).

When it executes, the console.log call goes to the browser’s JavaScript console , not the server.

Why the others are incorrect:

B. On the terminal console running the web server

That console shows logs from the server-side runtime (e.g., Node.js logs).

This code is clearly browser-side JavaScript (no Node.js or server context shown).

Therefore, the output does not appear in the terminal.

C. In the browser performance tools log

Performance tools (Timeline, Performance tab, etc.) show metrics about rendering, CPU time, network, etc., not generic console.log messages.

console.log messages appear in the Console tab, not in performance logs.

D. On the webpage console log

There is no built-in concept of a “webpage console log” UI rendered on the page itself by default.

Unless you explicitly code something to display logs in the DOM, console.log output is not visible on the page, only in Developer Tools.

Therefore, the correct place to see that log is:

Answer: A

JavaScript knowledge / Study Guide references (concept names only, no links):

Browser Developer Tools – Console tab

console.log() in client-side JavaScript

Difference between client-side logs and server-side logs

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)

JSON.stringify() applies the following rules:

String objects (new String( ' false ' )) Are converted to their primitive string values . So:

new String( " false " ) → " false "

Boolean objects (new Boolean(false)) Convert to their primitive boolean value :

new Boolean(false) → false

Undefined values inside arrays According to the JSON specification, undefined becomes null when stringifying an array:

JSON.stringify([undefined]) → " [null] "

Therefore, the array becomes:

[ " false " , false, null]

And JSON.stringify wraps it in quotes:

' [ " false " , false, null] '

This is exactly option A.

JavaScript Knowledge References (text-only)

Object wrappers (String, Boolean) are converted to primitives during JSON serialization.

undefined becomes null inside arrays when stringified.

JSON.stringify() follows the JSON data-model rules strictly.

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

The correct answer is B .

This question is about the event-driven programming model commonly used in Node.js. Many Node.js libraries expose an .on() method to register callback functions for specific events.

The correct pattern is:

ws.on( ' eventName ' , callbackFunction);

In this case, the developer needs to listen for two events:

' connect '

and:

' error '

The correct implementation is:

ws.on( ' connect ' , () = > {

console.log( ' Connected to client ' );

});

ws.on( ' error ' , (error) = > {

console.log( ' ERROR ' , error);

});

This registers one listener for successful connection and another listener for connection errors.

Why this works professionally:

ws.on( ' connect ' , callback) tells the library:

“When the connection event happens, execute this callback.”

ws.on( ' error ' , callback) tells the library:

“When an error event happens, execute this callback and pass the error object into it.”

Option A is incorrect because .catch() is used with Promises. The question specifically says the client library is built using events and callbacks , not Promise chaining.

Option D is incorrect because try...catch only catches synchronous errors during the immediate execution of ws.connect(). It will not reliably catch asynchronous connection errors emitted later by the web socket client.

Option C is identical to option B in the provided question. Since the expected answer normally requires selecting one option, B is selected as the verified answer.

Therefore, the verified answer is B .

ES Modules follow these rules:

Default exports are imported using:

import anyName from ' module '

The name chosen in the import does NOT need to match the exported name.

If a module exports:

export default function printDate() {}

then consuming code should import the function directly:

import printDate from ' /path/DatePrettyPrint.js ' ;

To execute it:

printDate();

Option analysis:

A incorrect: import DatePrettyPrint() is invalid syntax. Also calling printDate() without importing it is incorrect.

B incorrect: A default export imported as DatePrettyPrint gives the function itself, not an object containing methods. You cannot call DatePrettyPrint.printDate().

C incorrect: Imports printDate but then calls DatePrettyPrint.printDate(), which does not exist.

D correct: Correct import of a default-exported function. Correct direct invocation.

JavaScript Knowledge References (text-only)

Default export → imported without braces.

Importing default functions gives a callable function, not an object.

Correct syntax: import identifier from " module " .

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

objA is { value: 10 }.

objB = objA; → both variables reference the same object .

changeValue(objB);:

obj.value = obj.value / 2; // modifies the shared object

So:

objA.value becomes 10 / 2 = 5.

Thus result is 5.

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 start with:

let productSKU = ' 8675309 ' ;

The requirement:

Final SKU string:

Length: 19 characters.

Starts with ' sku ' .

Remaining characters are digits padded with zeros on the left (to reach total length).

We can use String.prototype.padStart and String.prototype.padEnd:

str.padStart(targetLength, padString)

If str.length < targetLength, it adds padString to the start until the length is targetLength.

str.padEnd(targetLength, padString)

Similar, but adds padString to the end.

We want a pattern like:

First, pad the numeric part out to a fixed length with zeros.

Then, pad to total length with ' sku ' at the start.

Analyze Option B

productSKU = productSKU.padStart(16, ' 0 ' ).padStart(19, ' sku ' );

Step 1: productSKU.padStart(16, ' 0 ' )

Initial productSKU is ' 8675309 ' (length 7).

After padStart(16, ' 0 ' ), we pad zeros on the left to reach length 16.

We need 16 − 7 = 9 zeros:

Result after step 1:

productSKU === ' 0000000008675309 ' // length 16

Step 2: .padStart(19, ' sku ' )

Now productSKU has length 16.

We call padStart(19, ' sku ' ):

We need 19 − 16 = 3 extra characters.

The pad string ' sku ' is exactly 3 characters, so it is added as-is at the start.

Result after step 2:

productSKU === ' sku0000000008675309 ' // length 19

This satisfies:

Length 19.

Starts with ' sku ' .

Remaining characters are zeros plus the original digits, i.e. a zero-padded numeric section.

While the literal sample sku000000008675309 in the text has a slightly different count of zeros, Option B follows the requirement pattern:

3 characters of ' sku '

Numeric part padded with zeros to make 16 characters total for the numeric part

3 + 16 = 19 total characters

Option B matches the intended logic using padStart and padEnd.

Why the other options are incorrect

Option A:

productSKU = productSKU.padEnd(16, ' 0 ' ).padStart( ' sku ' );

padEnd(16, ' 0 ' ) produces ' 8675309000000000 ' (original number followed by zeros).

padStart( ' sku ' ) is invalid usage:

padStart takes a numeric target length as the first argument, not a string.

Passing ' sku ' as the first argument leads to type coercion that does not achieve the intended behavior.

This will not reliably produce the desired SKU.

Option C:

productSKU = productSKU.padEnd(16, ' 0 ' ).padStart(19, ' sku ' );

First padEnd(16, ' 0 ' ) from ' 8675309 ' gives ' 8675309000000000 ' (length 16, zeros at the end).

Then padStart(19, ' sku ' ) adds 3 chars ' sku ' at the front:

Result: ' sku8675309000000000 ' .

This string starts with ' sku ' , but the zeros are at the end of the digits, not padding the numeric part on the left as desired.

Option D:

productSKU = productSKU.padStart(19, ' 0 ' ).padStart( ' sku ' );

First padStart(19, ' 0 ' ) pads zeros at the left to make the length 19.

Then padStart( ' sku ' ) again incorrectly uses a string where a numeric targetLength is required.

This will not produce the correct SKU format.

Therefore, the only option that correctly uses padStart to create a 16-character zero-padded numeric portion and then a 19-character string starting with ' sku ' is:

Answer: B

References / Study Guide concepts (no links):

String.prototype.padStart(targetLength, padString)

String.prototype.padEnd(targetLength, padString)

String length calculations

Left-padding numeric strings with zeros

Building prefixed identifiers with fixed total length

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

Requirement:

getNextValue() should run only if handleObjectValue(x) does not throw an error.

If an error occurs, handleError(error) should run, and getNextValue() should be skipped.

Option B:

try {

handleObjectValue(x);

getNextValue();

} catch (error) {

handleError(error);

}

Behavior:

If handleObjectValue(x) succeeds (no error):

Execution continues to getNextValue();.

If handleObjectValue(x) throws:

Control jumps directly to catch, getNextValue() is skipped.

handleError(error); is called.

This matches the requirement perfectly.

Why others are incorrect:

A: } then { is invalid JavaScript syntax.

C:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

}

getNextValue();

getNextValue() is called after the try...catch regardless of whether an error occurred. Not acceptable.

D: finally always runs:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

} finally {

getNextValue();

}

getNextValue() will execute in both success and error cases.

Therefore, the correct approach is B.

Concepts: try/catch control flow, finally semantics, placing code inside vs outside try/catch blocks.

The correct answer is B because variable a is declared and initialized before it is printed.

let a = " * " ;

This creates a block-scoped variable named a and assigns it the string value:

" * "

The line:

// x = 3;

is a comment. JavaScript ignores comments during execution, so this line has no effect.

Then this line runs:

console.log(a);

Since a already exists and contains " * " , the console displays:

*

Option A is incorrect because a is defined.

Option C is incorrect because a has an assigned value, so it is not undefined.

Option D is incorrect because a was never assigned null.

Therefore, the verified answer is B .

When execution hits the debugger; statement on line 06, JavaScript execution pauses at that point. Most modern browsers (for example, using DevTools) allow you to inspect the current scope , DOM, and various browser APIs in the console.

Let’s look at what is available precisely at line 06.

Current code state at the breakpoint:

Lines 01–04 define the Car constructor function.

Line 05 executes:

let carSpeed = document.getElementById( ' carSpeed ' );

So at line 06:

carSpeed is a variable containing a reference to a DOM element (the element with id " carSpeed " ).

Line 07 has not executed yet:

let fourWheels = new Car(carSpeed.value, ' red ' );

So fourWheels has not been created and is not accessible yet (it is in the temporal dead zone for the let declaration).

Now check each option:

Option A:

" A variable displaying the number of instances created for the Car object "

This code does not implement any mechanism to count instances of Car.

There is no static property, global counter, or similar variable tracking the number of Car instances.

At line 06, no instance of Car has even been created yet (new Car(...) is on line 07, which has not run).

Therefore, there is no such variable by default in JavaScript or DevTools.

This option is not available.

Option B:

" The information stored in the window.localStorage property "

At a breakpoint, the console is fully usable to inspect global objects.

window.localStorage is always accessible from the console (assuming standard browser context).

You can type:

window.localStorage

and inspect key/value pairs stored there.

This is independent of the current function or breakpoint line; localStorage is part of the Web Storage API on the window object.

So this information is indeed available in the console at line 06.

Option C:

" The values of the carSpeed and fourWheels variables "

At line 06:

carSpeed has been declared and assigned (line 05), so it is available, and its value (a DOM element) can be inspected.

fourWheels is declared on line 07 with let and has not yet been executed.

Variables declared with let and const are in a temporal dead zone before their declaration line completes.

At line 06, fourWheels is not yet initialized, and attempting to access it would result in a ReferenceError.

Thus, you can inspect carSpeed but not fourWheels. The option explicitly says " the values of the carSpeed and fourWheels variables " , which is not correct at this breakpoint, because fourWheels is not available yet.

Option D:

" The style, event listeners and other attributes applied to the carSpeed DOM element "

carSpeed holds a reference to a DOM element (document.getElementById( ' carSpeed ' )).

In DevTools, you can inspect this element in several ways:

Typing carSpeed in the console.

Inspecting it in the Elements panel.

From the console or Elements panel, you can view:

Its style (inline styles and computed styles).

Event listeners attached to it (using event listener viewer in DevTools).

Other attributes (id, class, etc.).

All of this is accessible at the point where execution is paused.

Therefore, this information is available at the breakpoint.

Conclusion:

B is available (global window.localStorage).

D is available (full inspection of the carSpeed DOM element).

A is not present in this code or environment.

C is partially wrong (only carSpeed exists; fourWheels does not yet).

So the two correct answers are:

Answer: B, D

References of JavaScript knowledge documents or Study Guide (concept names only):

debugger statement and pausing execution

JavaScript execution context and scope at a breakpoint

let declarations and temporal dead zone

Browser DevTools console and inspection of variables

DOM access via document.getElementById and inspection of elements

Web Storage API: window.localStorage

fullName is defined as a getter :

get fullName() { ... }

Getters are accessed like properties , not like functions.

So:

cat.fullName; // " Fancy Whiskers "

No parentheses.

Why others are wrong:

A: cat.fullName() tries to call the returned string as a function.

B and C: These properties (get, function) do not exist; they are misinterpretations of syntax.

Option A:

this.growl = () = > { ... } inside the constructor creates a new function per instance .

For 1000 new Monster(), you get 1000 distinct growl functions , each stored on the instance itself.

Option B:

Monster.prototype.growl = () = > { ... } attaches growl to the prototype.

All instances share the same single growl function via the prototype chain.

For 1000 instances, only 1 growl method exists in memory.

So: Option A → 1000; Option B → 1.

We want to select the first < li > under #main and change its content.

document.querySelector(selector) returns the first element matching the CSS selector.

In the DOM, the < li > elements under < ul > are children in order:

1st child: " Leo "

2nd child: " Tony "

3rd child: " Tiger "

li:nth-child(1) is the CSS pseudo-class that selects the first < li > inside its parent.

So:

document.querySelector( ' #main li:nth-child(1) ' ).innerHTML = ' The Lion ' ;

selects the first < li > ( " Leo " ) inside #main and sets its innerHTML to " The Lion " .

Why others are incorrect:

A. #main #Leo

There is no element with id " Leo " . id is not set on the < li > , so the selector matches nothing.

B. li:second-child

There is no :second-child pseudo-class. The valid pseudo-class is :nth-child(2); and that would select " Tony " , not " Leo " .

C. ' #main li,Leo '

This selector means “all #main li and all elements named < Leo > ”.

There is no < Leo > tag, and querySelectorAll returns a NodeList, which does not have a single innerHTML property.

Therefore, D is the correct statement.

Study Guide Concepts:

document.querySelector vs querySelectorAll

CSS selectors: nth-child()

DOM element innerHTML property

Comprehensive and Detailed Explanation From JavaScript/Node.js Knowledge:

In a Node.js project that uses package.json, you typically define a " start " script:

{

" scripts " : {

" start " : " node server.js "

}

}

Then you start the app with:

npm start

npm start:

Looks up the " start " script in package.json.

Runs the command defined there (commonly node server.js).

This is the standard way to start a Node.js app with npm-managed dependencies.

Why others are incorrect:

A. node start

Tries to run a file named start with Node; does not use package.json scripts.

C. npm start server.js

npm start does not take the script filename as an argument in this way; it just runs the start script as defined.

D. start server.js

Not an npm or node command; on some shells it just tries to “start” a process but is not the standard Node/npm workflow.

Relevant concepts: package.json, npm scripts, npm start, Node entry file execution.

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.

First, recall the fizzbuzz rules:

If n divisible by 3 and not by 5 → return ' fizz ' .

If n divisible by 5 and not by 3 → return ' buzz ' .

If n divisible by both 3 and 5 → return ' fizzbuzz ' .

Otherwise → return ' ' (empty string).

Evaluate each test:

Option A:

let res = fizzbuzz(true);

console.assert(res === ' ' );

In JavaScript, when using arithmetic operations with true, it is coerced to the number 1. A typical implementation of fizzbuzz would treat the argument as a number and compute:

true % 3 → 1 % 3 → 1

true % 5 → 1 % 5 → 1

So true is effectively treated as 1, which is divisible by neither 3 nor 5. The function should return ' ' . The assertion res === ' ' will pass.

This test covers the scenario “neither divisible by 3 nor 5”.

Option B:

let res = fizzbuzz(3);

console.assert(res === ' ' );

3 is divisible by 3 but not by 5.

According to fizzbuzz rules, fizzbuzz(3) should return ' fizz ' .

This test expects ' ' , so it is incorrect; the assertion would fail in a correct implementation.

Option C:

let res = fizzbuzz(5);

console.assert(res === ' fizz ' );

5 is divisible by 5 but not by 3.

According to fizzbuzz rules, fizzbuzz(5) should return ' buzz ' .

This test expects ' fizz ' , so it is incorrect.

Option D:

let res = fizzbuzz(15);

console.assert(res === ' fizzbuzz ' );

15 is divisible by both 3 and 5.

According to fizzbuzz rules, fizzbuzz(15) should return ' fizzbuzz ' .

This assertion correctly matches the expected result, so it is a proper test case.

Thus, the two test cases that correctly test valid fizzbuzz behavior are:

Answer: A, D

Study Guide / Concept References (no links):

Modulo operator (%) for divisibility checks

Truthy/number coercion of boolean true in arithmetic (Number(true) === 1)

Designing unit tests with console.assert

Typical fizzbuzz logic structure and expected outputs

Recall:

NaN stands for “Not-a-Number”.

Arithmetic involving non-numeric values that cannot be converted to numbers often results in NaN.

Check each:

A. 10 / 0

In JavaScript, dividing a positive number by 0 results in Infinity, not NaN.

So this logs Infinity.

B. parseInt( ' two ' )

parseInt tries to parse a numeric prefix from the string.

' two ' does not start with numeric digits, so parseInt( ' two ' ) returns NaN.

The console log prints NaN.

C. 10 / Number( ' 5 ' )

Number( ' 5 ' ) → 5.

10 / 5 → 2.

Logs 2, not NaN.

D. 10 / ' five '

' five ' is coerced to a number using Number( ' five ' ), which is NaN.

10 / NaN → NaN.

Logs NaN.

So the console logs that output NaN are from B and D.

Relevant concepts: NaN, Infinity, parseInt, Number() coercion, arithmetic with invalid numeric values.

The correct answer is C .

The original option contains a typing error. It should use the existing variable name:

let numberValue = Number(strNumber);

The value of strNumber is a string:

' 12345 '

Using Number() converts the numeric string into a JavaScript number:

12345

So after execution:

typeof numberValue;

returns:

" number "

Professional review of each option:

Option

Result

Explanation

A

Incorrect

JavaScript does not have a standard global Integer() conversion function.

B

Incorrect

Strings do not have a standard .toInteger() method.

C

Correct

Number(strNumber) correctly converts ' 12345 ' into 12345.

D

Incorrect

This is not valid JavaScript casting syntax.

A commonly used alternative would also be:

let numberValue = parseInt(strNumber, 10);

But from the provided answer choices, the verified answer is C .

Expression:

true + ' 13 ' + NaN

The + operator is left-associative, so evaluation order:

true + ' 13 '

When one operand is a string, + performs string concatenation.

true is converted to string ' true ' .

' true ' + ' 13 ' → ' true13 ' .

Result from step 1 with NaN:

' true13 ' + NaN

Again, one operand is a string, so concatenation.

NaN is converted to string ' NaN ' .

' true13 ' + ' NaN ' → ' true13NaN ' .

Final value: ' true13NaN ' .

So A is correct.

Why others are wrong:

B: ' 113NaN ' would require true to coerce to 1 first and no string to be present, which is not the case because ' 13 ' forces string concatenation.

C: 14 would require pure numeric addition, which is not the case once a string is involved.

D: ' true13 ' ignores the final + NaN part.

Concepts: type coercion with +, boolean to string, NaN to string, left-associative evaluation.

The correct answer is C .

The typing errors in the options should be corrected as follows:

event.stopPropagation();

The stopPropagation() method is used to stop an event from continuing through the DOM event propagation path.

A click event normally goes through these phases:

Capturing phase → Target phase → Bubbling phase

Because the event listener is attached to the button:

el.addEventListener( " click " , printMessage, false);

the function printMessage receives the click event when the button is clicked. To stop the event from bubbling up to parent elements, the event object should be accepted as a parameter and stopPropagation() should be called inside the event handler.

Corrected code:

< html >

< body >

< div id= " logo " > Hello Logo! < /div >

< button id= " test " > Click me < /button >

< /body >

< script >

function printMessage(event) {

event.stopPropagation();

console.log( ' This is a test message ' );

}

let el = document.getElementById( ' test ' );

el.addEventListener( " click " , printMessage, false);

< /script >

< /html >

Why this is correct:

event.stopPropagation();

prevents the click event from moving upward to ancestor elements after the button’s handler runs.

Why the other options are incorrect:

A and B are incorrect because removeEventListener() is used to remove a previously registered event listener. It does not stop event bubbling for the current event.

D is incorrect because stopPropagation() should be called inside the active event handler that receives the event object. In this case, that function is:

printMessage(event)

Therefore, the verified answer is C .

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)

document.cookie retrieves the cookie string.

Setting document.cookie = ' key=John Smith ' adds or updates only that one cookie.

Important details:

Writing to document.cookie does not overwrite all cookies .

The browser does not require URL encoding , though it is recommended. Non-encoded spaces are allowed and automatically handled.

document.cookies does not exist; the correct property is document.cookie.

Therefore, the correct behavior:

Cookies are read.

A new cookie key=John Smith is set.

Existing cookies remain.

JavaScript Knowledge References (text-only)

Writing document.cookie appends or updates cookies, not replaces them.

document.cookie is both getter and setter for cookie strings.

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

In JavaScript, when calling a constructor function without new:

const m = Monster();

the following happens:

The function executes as a normal function , not as a constructor.

Inside a regular function (in non-strict mode), this refers to the global object :

In a browser: window

So the line:

this.name = ' hello ' ;

becomes:

window.name = ' hello ' ;

Since Monster() does not return anything, its return value is undefined:

const m = undefined;

Therefore:

m is undefined

window.name becomes " hello "

This matches option B .

JavaScript Knowledge References (text-only)

Calling a function without new uses the global object as this in non-strict mode.

Constructor functions must use new to create a new object.

Functions without an explicit return return undefined.

The correct answers are B and D .

A strong test case checks whether the actual output matches the expected behavior of the function.

For Option B :

let res = fizzbuzz(15);

console.assert(res === ' fizzbuzz ' );

The number 15 is divisible by both 3 and 5:

15 % 3 === 0

15 % 5 === 0

So the correct return value is:

' fizzbuzz '

That makes option B a valid test.

For Option D :

let res = fizzbuzz(Infinity);

console.assert(res === ' ' );

Infinity is not a normal finite divisible number. In JavaScript:

Infinity % 3

Infinity % 5

produce NaN, and comparisons such as:

Infinity % 3 === 0

are false.

So a typical fizzbuzz implementation would not treat Infinity as divisible by 3 or 5, meaning it should return:

' '

That makes option D a valid test for the “neither divisible by 3 nor 5” path.

Now compare the incorrect options:

Option A is wrong because:

fizzbuzz(3)

should return:

' fizz '

not:

' buzz '

Option C is wrong because the function specification says the function returns strings such as ' fizz ' , ' buzz ' , ' fizzbuzz ' , or ' ' . It does not say the function returns numeric NaN.

So this assertion is not appropriate:

console.assert(isNaN(res));

Therefore, the verified answers are B and D .

Comprehensive and Detailed Explanation:

The loop removes every 4:

Start: [1, 2, 3, 4, 4, 5, 4, 4]

i=0 → 1 (no change)

i=1 → 2 (no change)

i=2 → 3 (no change)

i=3 → 4 → splice removes index 3 → [1,2,3,4,5,4,4], then i-- → 2

Next loop, i=3 → 4 again → splice → [1,2,3,5,4,4], i-- → 2

i=3 → 5 (no change)

i=4 → 4 → splice → [1,2,3,5,4] , i-- → 3

i=4 → 4 → splice → [1,2,3,5], i-- → 3

Next i=4, array.length is 4 → loop ends.

All 4s removed, final array: [1, 2, 3, 5].

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.

When async is added to a function:

async function example() {}

JavaScript guarantees:

The function always returns a Promise , regardless of what is returned inside.

Inside the function, await pauses execution until a Promise resolves.

Code appears synchronous even though it uses asynchronous behavior.

Analysis of each option:

A incorrect: Not " sometimes " —an async function always returns a Promise.

B incorrect: Async functions can be called just like normal functions.

C incorrect: Async/await has nothing to do with classes specifically.

D correct: This is the standard description: “Async functions behave asynchronously but allow writing code that looks synchronous.”

JavaScript Knowledge References (text-only)

async functions always return Promises.

await pauses execution of the async function.

Async/await syntax creates synchronous-looking code on top of asynchronous operations.

There are two valid ways to ensure leo.roar() exists:

Directly assign a roar function to leo (Option A). Assigning a property to an instance object creates a new method on that instance.

leo.roar = () = > { console.log( ' They\ ' re pretty good! ' ); };

After this, calling leo.roar() is valid.

Copy tony’s properties into leo using Object.assign (Option B). Object.assign(target, source) copies enumerable own properties from the source object into the target object. Since tony.roar exists, executing:

Object.assign(leo, tony);

copies roar into leo, making leo.roar() valid.

Why the other answers are incorrect:

Option C: Object.assign(leo, Tiger) copies properties from the function object Tiger , not from Tiger.prototype and not from a Tiger instance. Tiger (the function) has no roar property, so nothing useful is copied.

Option D: leo.prototype is undefined because leo is an instance, not a constructor function. Only constructor functions have a .prototype property. This line would cause an error.

JavaScript Knowledge References (text-only)

Instances have their own properties and do not contain a .prototype property.

Object.assign(target, source) copies own enumerable properties of the source object.

Assigning a function as a property of an object creates a callable method.

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

Comprehensive and Detailed Explanation:

Evaluate step by step:

' 15 ' + 10

+ with a string operand performs string concatenation.

10 is coerced to ' 10 ' .

Result: ' 1510 ' .

' 1510 ' * 2

* always performs numeric multiplication.

' 1510 ' is converted to the number 1510.

1510 * 2 = 3020.

So x is 3020.

A correct conversion from constructor-function syntax to ES6 class syntax must satisfy:

Use a constructor(name, price) method.

Assign instance properties inside the constructor.

Define methods without function keyword directly in the class body.

Use proper JavaScript template literals (backticks).

Evaluate each option:

Option A

Incorrect template literal syntax: uses single quotes with ${} which will not interpolate.

Option B

Incorrect:

The method vehicle() is not recognized as a constructor.

The constructor method is missing.

Option C

Incorrect:

The constructor has no parameters, but uses name and price which are undefined.

Option D

Correct:

Uses proper constructor with parameters.

Correct assignment of instance properties.

Correct template literal using backticks.

This is the valid ES6 class translation.

JavaScript Knowledge References (text-only)

ES6 classes require a constructor method for initialization.

Template literals must use backticks.

Methods inside classes are defined without the function keyword.

Omitted constructor parameters lead to undefined instance fields.

Currently:

sayHello expects a value name and prints it.

world is a function that returns ' World ' .

sayHello(world); passes the function object itself, not the result of calling it.

So name inside sayHello is a function, not the string " World " .

To keep the call sayHello(world) yet get " World " , sayHello must call the function parameter:

const sayHello = (name) = > {

console.log( ' Hello ' , name());

};

Now:

sayHello(world) passes the function.

Inside sayHello, name() calls world(), which returns " World " .

The console logs " Hello World " .

Why the others are wrong:

B: Changing line 7 to }(); would attempt to IIFE the function definition and break the declaration.

C: sayHello(world)() would try to call the return value of sayHello, which is undefined, causing an error.

D: Changing world to a function declaration does not change the fact that it is passed as a function reference; sayHello still prints the function object, not ' World ' .

The correct answers are A, C, and E .

Node.js allows JavaScript to run outside the browser. That makes it useful for backend development, command-line tools, APIs, real-time applications, and server-side services.

A is correct because Node.js executes JavaScript on the server side.

A team that already knows:

HTML

CSS

JavaScript

can use JavaScript for backend development as well. This reduces the need to switch to a completely different backend language.

Example:

const http = require( ' http ' );

const server = http.createServer((req, res) = > {

res.end( ' Hello from Node.js ' );

});

server.listen(3000);

This is server-side JavaScript.

C is correct because Node.js uses a non-blocking, event-driven model.

For API servers, this is valuable because Node.js can handle many I/O operations without blocking the entire process while waiting for tasks like:

database queries

file reads

network requests

API responses

Instead of waiting synchronously, Node.js can register callbacks, promises, or async functions and continue handling other work.

E is correct because Node.js commonly installs with npm, the Node Package Manager.

npm is used to install and manage third-party libraries, such as:

Express

Socket.IO

dotenv

Jest

Axios

This makes it easier to build backend applications using reusable packages.

Now review the incorrect answers:

B is incorrect because JavaScript is not primarily a static-analysis language by default. Node.js executes JavaScript at runtime. Static checking can be added with tools such as TypeScript, ESLint, or other analyzers, but that is not an inherent Node.js benefit.

D is incorrect because Node.js does not release one major version only every few years. Its release cycle is more frequent than that, so this is not an accurate benefit statement.

Therefore, the verified answers are A, C, and E .

The correct answers are B, C, D, and E .

JavaScript browser consoles support string substitution in several console output methods. String substitution means using placeholders such as:

%s

%d

%i

%f

%o

%O

%c

Example:

console.log( " User name is %s and age is %d " , " Alex " , 25);

Output:

User name is Alex and age is 25

The valid console methods from the given options are:

Option

Method

Correct?

Reason

A

message

No

console.message() is not a standard console method.

B

log

Yes

console.log() supports formatted string substitution.

C

assert

Yes

console.assert() can output a formatted message when the assertion is false.

D

info

Yes

console.info() supports formatted output like console.log().

E

error

Yes

console.error() supports formatted output and displays an error-style message.

Example with these valid methods:

console.log( " Name: %s " , " John " );

console.info( " Score: %d " , 95);

console.error( " Error code: %d " , 500);

console.assert(false, " Failed check for user: %s " , " Admin " );

So the verified answers are B, C, D, and E .

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

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.