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

The correct answer is B because the JavaScript browser console allows developers to interact with the current web page using JavaScript commands. Through the console, you can access the document object, inspect DOM elements, read their properties, and modify the structure or content of the page.

For example:

document.body.style.backgroundColor = " lightblue " ;

This changes the page’s background color.

Another example:

document.querySelector( " h1 " ).textContent = " Updated Heading " ;

This changes the text of the first < h1 > element on the page.

The DOM , or Document Object Model, is the browser’s JavaScript representation of the HTML page. Since the console runs JavaScript in the context of the current page, it can be used to inspect and modify DOM elements directly.

Why the other options are incorrect:

A is not the best answer because although you can type general JavaScript expressions in the console, the browser console is mainly connected to the current page’s execution environment. The question is asking about practical browser-console actions related to a page.

C is incorrect because performance reports are usually generated through tools such as the Performance panel or Lighthouse in browser developer tools, not directly through the JavaScript console.

D is incorrect because the console can modify the DOM and runtime values, but it does not permanently change the original JavaScript source code of the page. Any changes made through the console are temporary and disappear when the page reloads.

E is incorrect because security-protected cookies, such as HttpOnly cookies, cannot be viewed or changed using JavaScript. This is an intentional browser security feature that prevents client-side scripts from accessing sensitive cookie data.

Therefore, the best verified answer is B .

str = ' Salesforce '

Index positions:

S(0) a(1) l(2) e(3) s(4) f(5) o(6) r(7) c(8) e(9)

substring(start, end)

Start index inclusive, end index exclusive.

str.substring(0, 5) → characters at indices 0–4 → " Sales "

str.substring(1, 5) → indices 1–4 → " ales "

substr(start, length)

Start index, then number of characters.

str.substr(0, 5) → 5 characters starting at index 0 → " Sales "

str.substr(1, 5) → 5 characters from index 1 → " alesf "

So the expressions that return " Sales " 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 C , after correcting the option text to match the actual code.

The object is created here:

let student = new GraduateStudent( " Jane " );

Because GraduateStudent extends Student, its constructor runs:

constructor(name) {

super(name);

this._name = " Graduate Student " + name;

}

The call to:

super(name);

runs the parent Student constructor first and temporarily sets:

this._name = " Jane " ;

Then this line in the child constructor overwrites that value:

this._name = " Graduate Student " + name;

So the final value of this._name becomes:

" Graduate Student Jane "

Next, this line executes:

student.displayGrade();

Since student is an instance of GraduateStudent, JavaScript uses the overridden displayGrade() method from GraduateStudent, not the parent method from Student.

The executed method is:

displayGrade() {

console.log(`${this._name} got 100% on test.`);

}

Therefore, the console output is:

Graduate Student Jane got 100% on test.

Important correction: the original option C said something like " Better student Jackie got 100% on test. " , but the actual code uses " Graduate Student " and the name " Jane " . The verified corrected answer remains C .

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.

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

Current behavior:

Clicking < td > triggers the click event on row1, then bubbles up to < table > .

printMessage runs, logs " Row log " , then event.stopPropagation() stops the event from bubbling to the table.

So " Table log " never appears.

To allow the table’s inline onclick to run after the row handler:

Remove the propagation stop:

function printMessage(event) {

console.log( ' Row log ' );

// event.stopPropagation(); // remove this

}

Now the event bubbles:

printMessage logs " Row log " .

The table’s onclick runs, logging " Table log " .

Option A only changes capture/bubble phase but still stops propagation. C does nothing meaningful (stopPropagation takes no arguments). B removes the row handler entirely.

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

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.

React and Vue are:

Mature front-end JavaScript frameworks/libraries.

Have large communities.

Are widely supported and used in production across industries.

Appropriate for building browser-based Single Page Applications.

Express and Koa are server-side frameworks , not front-end SPA frameworks.

The scenario describes building a browser SPA, so the correct seasoned options are React and Vue.

JavaScript Knowledge References (text-only)

React and Vue are client-side frameworks for SPA development.

Express and Koa are backend frameworks for Node.js.

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

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.

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

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 corrected answers are C, D, and E .

This function is a normal function, not a curried function:

function sum(num1, num2, num3) {

if (num3 === undefined) {

num3 = 0;

}

return num1 + num2 + num3;

}

It expects values to be passed in the same function call:

sum(num1, num2, num3);

Now check the valid corrected options.

Option C:

sum(5, 5, 0);

Calculation:

5 + 5 + 0

Result:

10

So C is correct .

Option D:

sum(10, 0);

Here, num3 is not provided, so it is undefined.

The function checks:

if (num3 === undefined) {

num3 = 0;

}

So the calculation becomes:

10 + 0 + 0

Result:

10

So D is correct .

Option E:

sum(5, 2, 3);

Calculation:

5 + 2 + 3

Result:

10

So E is correct .

Why A and B are incorrect as originally written:

sum(5)(5);

This calls sum(5) first. Since num2 is missing, the result becomes NaN. Then JavaScript tries to call that returned value as a function, which causes a TypeError.

sum()(10);

This also calls sum() first, producing NaN, and then attempts to call NaN as a function.

Those styles would only work if sum were written as a curried function, but the given implementation is not curried.

Therefore, the verified corrected answers are C, D, and E .

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

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.

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 .

We want:

const addByEight = addBy(8);

const sum = addByEight(50);

And we need sum to be 58.

That means:

addBy(8) must return a function.

That returned function, when called with 50, must compute 8 + 50.

So addBy must be a higher-order function that returns another function capturing num1 and later using it with num2 (a closure).

Option A

const addBy = function(num1) {

return function(num2) {

return num1 + num2;

}

}

Step-by-step:

Call addBy(8):

num1 is 8.

The function returns an inner function: function(num2) { return num1 + num2; }.

So addByEight becomes this inner function, with num1 closed over as 8.

Then call addByEight(50):

num2 is 50.

The body computes num1 + num2, i.e., 8 + 50 = 58.

Therefore, with Option A in place:

const addByEight = addBy(8); // returns inner function

const sum = addByEight(50); // 58

So sum is 58. Option A is correct.

Option D (corrected)

const addBy = (num1) = > {

return function(num2) {

return num1 + num2;

}

}

This is essentially the same logic expressed with an arrow function for the outer function:

Call addBy(8):

num1 is 8.

Returns the inner function function(num2) { return num1 + num2; }.

Call addByEight(50):

num2 is 50.

Computes num1 + num2 → 8 + 50 = 58.

So again:

const addByEight = addBy(8); // inner function with num1 = 8

const sum = addByEight(50); // 58

Option D is also correct.

Thus, A and D are the two functions that satisfy the requirement.

Why B and C are incorrect

Option B:

const addBy = function(num1) {

return num1 * num2;

}

This does not return a function; it returns a value.

addBy(8) returns 8 * num2, but num2 is not defined in this scope, which would cause a ReferenceError.

Also, addByEight would be a number (if num2 existed), not a function, so addByEight(50) would fail.

Option C:

const addBy = (num1) = > num1 + num2;

Again, addBy returns a value, not a function.

addBy(8) returns 8 + num2, but num2 is not defined, so this is also invalid due to ReferenceError.

addByEight would be a number (or error), not a function.

Neither B nor C creates the required closure nor returns a function to be called later.

References / Study Guide concepts (no links):

Higher-order functions in JavaScript

Closures: inner functions capturing outer variables (num1)

Arrow functions vs function expressions

Returning functions from functions (function factories / currying)

Scope and ReferenceError when a variable is not defined

Initial values:

first = ' Who '

second = ' What '

Execution:

Inner try/catch/finally:

Line 05: throw new Error( ' Sad trombone ' );

Control goes to the inner catch.

Inner catch (lines 06–08):

catch (err) {

first = ' Why ' ;

throw err;

}

first is set to ' Why ' .

The error is rethrown.

Inner finally (lines 09–11):

finally {

second = ' When ' ;

}

finally runs whether or not there was an error.

second becomes ' When ' .

After inner finally, the rethrown error continues to propagate to the outer catch.

Outer catch (lines 12–14):

} catch (err) {

second = ' Where ' ;

}

Because the inner try rethrew, the outer catch runs.

It sets second = ' Where ' .

Final values:

first was changed to ' Why ' in the inner catch and never changed again.

second became ' When ' in the inner finally, and then ' Where ' in the outer catch.

So:

first is ' Why '

second is ' Where '

Option B is correct.

Concepts: nested try/catch/finally, rethrowing errors, order of execution for catch vs finally, variable mutation through error propagation.

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

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 " .

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

Node.js event-based modules use the EventEmitter pattern.

The correct syntax for listening to events is:

emitter.on( ' eventName ' , callback)

The server library emits an ' error ' event, which must be listened to using .on.

Option analysis:

A: .catch is for Promises, not EventEmitters.

B: .error is not an EventEmitter method.

C: Correct. Listens to the ' error ' event.

D: try...catch only captures synchronous errors, not event-based asynchronous errors.

Therefore, the correct answer is option C .

JavaScript Knowledge References (text-only)

The EventEmitter API uses on(event, handler) to listen for events.

Errors emitted asynchronously cannot be caught with try...catch.

The ' error ' event is standard for Node.js modules to signal operational errors.

In ES6 class syntax, the special method used to initialize a new instance is called constructor.

A class definition syntax:

class ClassName {

constructor(param1, param2) {

this.prop1 = param1;

this.prop2 = param2;

}

}

The constructor method:

Is called automatically when you create a new instance with new ClassName(...).

Receives the arguments passed in the new expression.

Assigns values to this to set instance properties.

Applying this to Story

We want to be able to write:

const article = new Story( ' Some body ' , ' Author Name ' , 100);

and have:

article.body === ' Some body '

article.author === ' Author Name '

article.viewCount === 100

To achieve this, the class must have:

class Story {

constructor(body, author, viewCount) {

this.body = body;

this.author = author;

this.viewCount = viewCount;

}

}

So the correct line 02 is:

constructor(body, author, viewCount) {

Why the other options are incorrect

A. constructor() {

This defines a constructor with no parameters.

The lines inside the constructor use body, author, and viewCount, which would be undefined unless they exist in an outer scope (they normally do not).

This would lead to the instance properties being set to undefined in normal usage.

B. super(body, author, viewCount) {

super(...) is used inside a constructor of a subclass to call the parent class constructor.

You cannot use super(...) { as a method definition; this is invalid syntax in a class body.

Additionally, Story as given is not shown extending any class, so super is inappropriate here.

C. function Story(body, author, viewCount) {

Inside a class definition, you do not use the function keyword to define methods.

function Story(...) here would be invalid syntax in a class body.

Even if it were allowed, the special constructor method for a class is named constructor, not the class name.

Therefore, only:

constructor(body, author, viewCount) {

correctly declares the constructor for the Story class and ensures instances created with new Story(body, author, viewCount) have all three properties populated.

References / Study Guide concepts (no links):

ES6 class syntax

constructor method in classes

this and instance properties in classes

Difference between class constructors and regular functions

Invalid use of super and function inside class bodies

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.

If the dependency was added as a dev dependency (yarn add --dev), it goes into devDependencies.

When NODE_ENV=production, Yarn (and npm) typically skip devDependencies on install.

Thus the package doesn’t get installed for other team members in a production environment.

YARN_ENV is not a standard variable, --save is npm syntax (and Yarn saves by default), and --add is not how Yarn works (the command itself is yarn add).

Comprehensive and Detailed Explanation:

" Salesforce " indices: S(0) a(1) l(2) e(3) s(4) f(5) …

A / C (substring(0, 5)):

substring(start, end) returns characters from start up to but not including end.

str.substring(0, 5) → characters at indices 0,1,2,3,4 → " Sales " .

D (substr(0, 5)):

substr(start, length) returns length characters starting at start.

str.substr(0, 5) → 5 chars from index 0 → " Sales " .

B is invalid because s is not defined; it should be 0. So the two correct statements are A and D.

The browser console (Developer Tools → Console) allows:

Running code unrelated to the page Developers can type arbitrary JavaScript not tied to the page’s logic. This is allowed → A is correct.

Viewing and modifying JavaScript code execution Using the Sources tab and console, developers can:

Inspect variables

Modify code at runtime

Set breakpoints Therefore → D is correct.

Viewing and manipulating the DOM From the console, developers can:

Query DOM nodes using selectors

Modify element properties and attributes

Insert or remove elements Therefore → E is correct.

Why the other options are incorrect:

B (security cookies) Many cookies have flags such as HttpOnly and Secure. Cookies with the HttpOnly flag cannot be viewed or modified via JavaScript or console. Therefore this is not guaranteed → incorrect.

C (performance report) The console itself does not provide a performance report. The Performance or Lighthouse tabs provide this, not the console. Therefore incorrect.

JavaScript Knowledge References (text-only)

Developer console can execute arbitrary JavaScript.

Console allows DOM inspection and manipulation.

Security cookies (HttpOnly) cannot be accessed via 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.

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 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

This question tests understanding of let (block scope) and var (function scope) in JavaScript.

Initial declarations in the function:

let x = 1; // line 2

var y = 1; // line 3

Here:

x is declared with let, so it is block-scoped to the function body.

y is declared with var, so it is function-scoped to the entire function.

Inside the if (reassign) block (and since reassign is true, we enter it):

if (reassign) {

let x = 2; // line 6

var y = 2; // line 7

console.log(x); // line 8

console.log(y); // line 9

}

Detailed behavior:

let x = 2; on line 6 creates a new block-scoped variable x that exists only inside the if block. It does not change the outer x declared on line 2.

var y = 2; on line 7 declares y with var again, but var is function-scoped. This effectively reassigns the same y defined on line 3 for the entire function. After this line, y is 2 everywhere in the function.

Now, inside the if block:

console.log(x); (line 8) logs the inner block-scoped x, which is 2.

console.log(y); (line 9) logs y, which is the function-scoped y that was set to 2.

So the first two outputs are:

2

2

After the if block, execution continues:

console.log(x); // line 12

console.log(y); // line 13

Outside the if block:

The block-scoped let x = 2; no longer exists; it was only visible inside the if block.

The outer let x = 1; (line 2) is still in scope and has not been changed.

Thus:

console.log(x); (line 12) logs the outer x, which is still 1.

console.log(y); (line 13) logs y which, due to var y = 2; inside the if, is now 2 for the whole function.

Therefore, when myFunction(true) is called, the output in order is:

2 (inner x in if)

2 (function-scoped y after reassignment)

1 (outer x after if)

2 (function-scoped y remains 2)

This corresponds to:

Answer: B (2 2 1 2)

JavaScript knowledge / study guide reference concepts:

let declarations and block scope

var declarations and function scope

Shadowing of variables with let inside a block

Re-declaration and reassignment of var within a function

Execution order of statements and console output

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 .

Node.js includes a built-in command-line (CLI) debugger . To use it directly in the terminal, the standard command is:

node inspect server.js

This:

Starts server.js under the Node.js inspector.

Opens the CLI debugger right in the terminal window where you ran the command.

Lets you interactively:

Step through code

Set breakpoints

Inspect variables

Continue execution, etc.

Why B is correct:

Option B (corrected to node inspect server.js) is exactly the standard Node.js command to run a script under the CLI debugger in the current terminal.

It does not rely on any external GUI tools.

You stay entirely in the terminal to debug.

Why the other options are incorrect:

A. node start inspect server.js

There is no start subcommand like this in standard Node.js CLI.

This is not a valid Node.js debugging command.

C. node server.js --inspect

This starts Node.js with the Inspector protocol enabled and is typically used to connect external tools like Chrome DevTools or VS Code.

It does not open the CLI debugger in the current terminal. Instead, it opens a debugging port that other tools attach to.

The question specifically says “only using the terminal” and “open the CLI debugger in their current terminal window”, which points to node inspect, not --inspect.

D. node -i server.js

-i starts Node in interactive REPL mode , optionally after running a script.

This is for an interactive shell, not the Node debugger.

It does not provide breakpoint/step/next/continue debugging features like the CLI debugger.

Therefore, the only option that opens the Node.js CLI debugger in the current terminal is:

Answer: B

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

Node.js CLI debugger: node inspect < script >

Node.js inspector protocol: node --inspect

Difference between CLI debugger and DevTools-based debugging

Node.js command-line options and subcommands

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.

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.

The correct answer is A .

JavaScript evaluates the expression from left to right:

true + 3 + ' 100 ' + null

Step 1:

true + 3

In numeric addition, true is converted to:

1

So:

true + 3

becomes:

1 + 3

Result:

4

Step 2:

4 + ' 100 '

Because one operand is a string, JavaScript performs string concatenation instead of numeric addition.

So:

4 + ' 100 '

becomes:

" 4100 "

Step 3:

" 4100 " + null

Again, because one operand is already a string, JavaScript converts null into the string:

" null "

So the final result is:

" 4100null "

Execution summary:

true + 3 + ' 100 ' + null

// 1 + 3 + ' 100 ' + null

// 4 + ' 100 ' + null

// " 4100 " + null

// " 4100null "

Therefore, the verified answer is A .

The correct answers are C and D .

The statement:

const arr = Array(5).fill(0);

creates an array with 5 elements , and every element is filled with the value 0.

So the array becomes:

[0, 0, 0, 0, 0]

A professional test should verify both important expectations:

arr.length === 5

and:

each element === 0

Option C is correct because it checks every element in the array:

arr.forEach(e = > console.assert(e === 0));

This confirms that each array element was filled with 0.

Option D is correct because it checks the array length:

console.assert(arr.length === 5);

This confirms that the array contains exactly five elements.

Option A is incorrect because the array length is not 0; it is 5.

Option B is incorrect for two reasons. First, arr[5] is outside the valid index range. The valid indexes are:

0, 1, 2, 3, 4

So:

arr[5]

returns:

undefined

Second, arr.length === 0 is false because the length is 5.

Therefore, the verified answers are C and D .

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.

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

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.

FishingBoat extends Ship, so it is a subclass. In ES6 classes:

When you define a constructor in a subclass, you must call super(...) before accessing this.

super(size) calls the parent class (Ship) constructor, which sets this.size = size.

So the correct constructor is:

class FishingBoat extends Ship {

constructor(size, capacity) {

super(size); // line 09

this.capacity = capacity;

}

displayCapacity() {

console.log(`The boat has a capacity of ${this.capacity} people.`);

}

}

Why others are incorrect:

B. ship.size = size;

ship is not defined; this would cause a ReferenceError.

C. super.size = size;

super is not an instance; you must call super(...) as a function to invoke the parent constructor.

D. this.size = size;

In a subclass constructor, you must call super() before using this, otherwise you get a ReferenceError. Also this bypasses the parent constructor logic.

Relevant concepts: ES6 class inheritance, extends, super() in subclass constructors, this initialization rules.

Evaluate each option:

A. Arguments for .then() are optional.

This is correct.

then() has the signature:

promise.then(onFulfilled?, onRejected?)

Both arguments (onFulfilled and onRejected) are optional.

If a callback is not supplied, JavaScript provides a default pass-through handler.

B. .then() cannot be added after a catch.

Incorrect.

Promises support chaining in any order:

promise

catch(...)

then(...);

After a catch, the chain continues normally.

C. .then() manipulates and returns the original promise.

Incorrect.

then() always returns a new promise , not the original one.

This is fundamental to promise chaining behavior.

D. Returning values in .then() is not necessary.

Incorrect.

If you want the next .then() in the chain to receive a value, the current .then() must explicitly return it:

then(value = > {

return value * 2; // passes to next .then()

})

If nothing is returned, the next .then() receives undefined.

Why A is correct

It is the only statement that accurately describes built-in Promise behavior:

then() accepts optional arguments.

JavaScript Knowledge References (text-only)

.then(onFulfilled?, onRejected?) accepts optional handlers.

Promise chaining creates new promises for each .then().

catch() can be followed by additional .then() calls.

Returning inside .then() passes values to the next step in the chain.

Inside setCurrentUrl, url is assigned without var, let, or const :

url = window.location.href;

In non–strict mode, this implicitly creates a global variable url on window.

Execution order:

setCurrentUrl(); creates/sets global url to window.location.href.

console.log( " The current URL is: " + url); has access to url in global scope and prints correctly.

Thus:

url has global scope.

Line 02 runs without error and logs a valid string.

So B is correct.