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

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.

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.

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

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.

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.

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

We have a ternary:

account.style.display = accountName.includes(parsedSearchString)

? /* if true */

/* if false */;

Requirement:

If the account matches the search string → show it.

If it does not match → hide it.

For display:

Show: ' block ' (or similar visible value).

Hide: ' none ' .

So we want:

account.style.display = accountName.includes(parsedSearchString)

? ' block '

' none ' ;

That corresponds to option A.

Why others are wrong:

B, C use values suitable for visibility, not display.

D ( ' none ' : ' block ' ) inverts the logic, hiding matches and showing non-matches.

We must understand pass-by-value for primitives in JavaScript.

Initial values:

let a = 10;

let b = a; // b gets a copy of the value 10

So:

a is 10

b is 10 (independent copy)

Function call:

changeValue(b);

Function definition:

function changeValue(param) {

param = 5;

}

param receives the value of b, which is 10.

Inside the function, param is a local variable .

param = 5; changes only this local copy.

It does not affect b outside the function.

After the function call:

a is still 10.

b is still 10.

Result:

const result = a + ' - ' + b;

a is 10.

b is 10.

String concatenation: ' 10 - 10 ' .

So result is:

" 10 - 10 "

Therefore, the correct option is:

Answer: D

Study Guide Concepts:

Primitive values (numbers, strings, booleans) are passed by value

Function parameters as local variables

String concatenation with +

Difference between mutating references vs primitives

Facts about JavaScript Promises:

runParallel() is declared async, which means it always returns a Promise .

Promises are consumed using .then(), .catch(), and .finally().

There is no .done() method in native JavaScript Promises.

The async keyword cannot be placed before a function call (option A is invalid syntax).

Analysis of each option:

A. async runParallel().then(data);

Invalid syntax. async cannot prefix an expression.

B. Valid. Calls the function and attaches a .then() handler.

C. Invalid. .done() is not part of JavaScript Promise API.

D. Valid. Calls runParallel() and chains .then().

Therefore the correct answers are B and D.

JavaScript Knowledge References (text-only)

async functions return Promises.

Promises use .then() to retrieve resolved values.

.done() is not part of the standard Promise interface.

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

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

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

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

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

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

In strict mode: this would throw a TypeError.

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

Therefore, the object remains:

{ title: " JavaScript " }

Both objBook and newObjBook point to the same unchanged object.

This matches option A.

JavaScript knowledge references (text-only)

Object.preventExtensions() prevents adding new properties.

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

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

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

In the getter:

let city = Number( " London " );

The Number() constructor attempts to convert the string " London " into a numeric value.

" London " is not a valid numeric string. When JavaScript attempts numeric conversion of a non-numeric string:

Number( " London " ) → NaN

Next line:

city.toString()

When city is NaN, calling .toString() yields:

NaN.toString() → " NaN "

The getter returns:

{

cityString: " NaN "

}

The question asks: Which value can a developer expect? The multiple-choice options include NaN , but not " NaN " .

Given the available choices, the intended correct answer is B (NaN) because the root cause is the Number( " London " ) conversion returning NaN.

JavaScript Knowledge References (text-only)

Number(nonNumericString) returns NaN.

NaN.toString() produces " NaN " .

Getters compute and return their values each time the property is accessed.

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

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

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 .

The correct answers are A and C because both use named exports for foo and bar.

A module can export multiple values by name:

export { foo, bar };

This allows another file to import them like this:

import { foo, bar } from ' ./utils.js ' ;

Option A is correct because it defines both functions locally and exports both of them as named exports.

const foo = () = > { return ' foo ' ; };

const bar = () = > { return ' bar ' ; };

export { foo, bar };

Option C is also correct after correcting the typing issue so that both foo and bar are imported first:

import { foo, bar } from " ./helpers/utils.js " ;

export { foo, bar };

This is called re-exporting. The module imports foo and bar from another module, then exports them again from utils.js.

Option B is not the best answer for named access because it exports one default object:

export default { foo, bar };

That would require a default import first:

import utils from ' ./utils.js ' ;

utils.foo();

utils.bar();

It does not directly support named imports in the same way as:

import { foo, bar } from ' ./utils.js ' ;

Option D exports a default class. Its foo() and bar() are class instance methods, not named exported functions. It would require usage like:

import Utils from ' ./utils.js ' ;

const utils = new Utils();

utils.foo();

utils.bar();

So for direct multiple function exports, the correct implementations are A and C .

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 .

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

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

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

console.log( ' Start ' ) runs immediately (synchronous).

Promise.resolve().then(...) places the callback in the microtask queue. The .then handler does not run immediately.

console.log( ' End ' ) runs next (still synchronous).

After the synchronous script finishes, the microtask queue runs, logging " Success " .

Execution order:

Start

End

Success

This matches option B .

JavaScript Knowledge References (text-only)

Promise .then() callbacks execute after the current call stack finishes (microtask queue).

Synchronous logs run immediately, before promise callbacks.

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

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.

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.

String: " Yay! Salesforce is amazing! "

Index positions:

' Y ' at 0, ' a ' at 1, ' y ' at 2, ' ! ' at 3, space at 4, ' S ' at 5, ' a ' at 6, ' l ' at 7, ' e ' at 8, ' s ' at 9, etc.

Substring " Sales " starts at index 5.

String.prototype.search with a regex returns the index of the first match or -1 if there is no match.

searchText.search(/sales/i);

/sales/i is case-insensitive because of the i flag.

It matches " Sales " beginning at index 5.

So result1 is 5.

searchText.search(/sales/);

/sales/ is case-sensitive.

It requires lowercase " sales " .

The text has " Sales " with uppercase S, so this does not match.

search returns -1 when there is no match.

So result2 is -1.

Console output:

First log: 5

Second log: -1

Option D matches this.

Concepts: regex search, case sensitivity vs i flag, String.prototype.search return values.

We want to convert the number 1982 to a string.

Check each option:

A. numValue.toText()

There is no standard toText() method on numbers.

This will result in TypeError: numValue.toText is not a function.

B. String(numValue);

String() as a function converts its argument to a string.

String(1982) returns " 1982 " .

This is correct.

C. ' ' + numValue;

' ' is a string; + with a string operand performs string concatenation.

' ' + 1982 → " 1982 " .

This is a common shorthand for number-to-string conversion.

D. numValue.toString();

Number.prototype.toString() converts the number to its string representation.

1982..toString() or (1982).toString() returns " 1982 " .

For the variable, numValue.toString() is valid: " 1982 " .

E. (String)numValue;

This is not valid JavaScript casting syntax; it is more like a C/Java-style cast.

In JavaScript, that is parsed as a grouping expression (String) and then numValue; it does not convert numValue to a string.

Thus the correct answers are:

B. String(numValue);

C. ' ' + numValue;

D. numValue.toString();

Relevant concepts: primitive type conversion, String() casting, .toString(), coercion via + with strings.

This question focuses on the typeof operator and how JavaScript represents the type of the value null.

Declaration on line 1:

let x = null;

Here:

x is explicitly assigned the value null.

In JavaScript, null is a special primitive value that represents “no value” or “empty value”.

Line 2:

console.log(typeof x);

The typeof operator returns a string indicating the type of the operand. For example:

typeof 1 returns " number "

typeof " hello " returns " string "

typeof true returns " boolean "

typeof undefined returns " undefined "

typeof {} returns " object "

typeof [] returns " object " (arrays are objects)

typeof function() {} returns " function "

For null, due to an early design decision in JavaScript, the result is:

typeof null === " object "

This is a known historical quirk of the language:

Although null is a primitive and conceptually means “no object”, typeof null returns the string " object " .

Therefore, typeof x when x is null evaluates to " object " .

So on line 2, the value printed is:

" object "

This matches option A.

The incorrect options are:

B. " undefined " : would be typeof x if x were undefined, not null.

C. " x " : typeof returns a string describing the type of the value, not the variable name.

D. " null " : although intuitive, JavaScript does not return " null " for typeof null; it returns " object " instead.

Therefore, the correct answer is:

Answer: A

JavaScript knowledge / study guide reference concepts:

typeof operator and its return values

Primitive types in JavaScript (null, undefined, number, string, boolean, symbol, bigint)

Historical behavior: typeof null returning " object "

Difference between null and undefined in JavaScript

The correct answer is A .

This object uses a getter :

get fullName() {

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

}

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

So the correct access syntax is:

dog.fullName

That returns:

" Beau Boo "

The important distinction is:

dog.fullName

not:

dog.fullName()

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

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

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

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

Therefore, the verified answer is A .

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.

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.

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.

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.

The File API in browsers provides the FileReader object to read file contents selected from < input type= " file " > .

Important knowledge points:

new FileReader() creates a file-reading object.

.readAsDataURL(file) reads a file and produces a Base64 URL string.

The " load " event fires when the file has finished reading.

reader.result contains the data URL after reading completes.

Therefore, the correct implementation must:

Create a FileReader instance:

const reader = new FileReader();

Call:

reader.readAsDataURL(file);

Use the load event handler to assign the image preview:

preview.src = reader.result;

Option B is the only option that matches valid JavaScript File API usage.

Option A is incorrect because File is not a constructor for reading files.

Option C is incorrect because URL.createObjectURL(file) must be assigned directly as a URL, not used with reader.result.

JavaScript Knowledge References (text-only)

The file-reading interface in browsers is FileReader.

readAsDataURL() loads files as Base64 data URLs.

The load event indicates when the reader has finished and reader.result is available.

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

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

A recursive function is a function that calls itself and has a base case to terminate the recursion.

Evaluate each option:

Option A:

const sumToTen = numVar = > {

if (numVar < 0)

return;

return sumToTen(numVar + 1);

};

This function calls itself: sumToTen(numVar + 1) — so it is recursive.

However, the base condition is if (numVar < 0) return;.

If you call sumToTen(0):

numVar < 0 is false, so it calls sumToTen(1), then sumToTen(2), and so on, incrementing forever.

There is no condition to stop the recursion when numVar increases; it will eventually cause a stack overflow.

This code does not represent a properly working recursive function with a valid termination for increasing values and is not a good example of correct recursion.

Option B:

function factorial(numVar) {

if (numVar < 0) return;

if (numVar === 0) return 1;

return numVar - 1;

}

This function does not call itself anywhere.

It has conditional returns, but there is no recursive call such as factorial(numVar - 1).

Therefore, it is not recursive at all.

Option C:

const factorial = numVar = > {

if (numVar < 0) return;

if (numVar === 0) return 1;

return numVar * factorial(numVar - 1);

};

This is a classic recursive factorial implementation.

It calls itself with a smaller argument: factorial(numVar - 1).

Base cases:

If numVar < 0, it simply returns (could be treated as invalid input).

If numVar === 0, it returns 1, which is the mathematical definition of 0! (zero factorial).

For positive integers, it correctly multiplies numVar by factorial(numVar - 1) until it reaches the base case.

This is a correct and working recursive function.

Option D (corrected):

let countingDown = function(startNumber) {

if (startNumber > 0) {

console.log(startNumber);

return countingDown(startNumber - 1);

} else {

return startNumber;

}

};

This function also calls itself: countingDown(startNumber - 1).

Base case:

When startNumber is not greater than 0 (i.e., 0 or negative), it returns startNumber and stops recursing.

For example, countingDown(3) would:

Log 3, call countingDown(2)

Log 2, call countingDown(1)

Log 1, call countingDown(0)

At 0, it hits the else branch and returns 0, ending the recursion.

This is a valid working recursive function structure (once syntax is corrected).

Therefore, the snippets that show working recursive functions are:

Answer: C, D

Study Guide / Concept References (no links):

Definition of recursion: a function calling itself

Base case vs recursive step

Recursive factorial implementation

Recursive countdown example

Importance of a terminating condition to avoid infinite recursion

In JavaScript, there is only one numeric type for ordinary numbers: number.

JavaScript number is a double-precision 64-bit binary format (IEEE 754).

There is no separate float, double, or decimal type in core JavaScript.

So:

typeof pi === ' number ' ;

Hence, the correct answer is:

A. Number

Options B, C, D are specific numeric types found in other languages (like C, Java, C#), not distinct types in JavaScript.

Study Guide Concepts:

JavaScript primitive types

typeof operator and number

Lack of separate float / double / decimal types in JS

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.

We want to guarantee that the result is of type string regardless of what var1 and var2 are (numbers, booleans, etc.).

Option A:

String(var1).concat(var2)

String(var1) converts var1 explicitly to a string.

.concat(var2) calls String.prototype.concat, which:

Converts var2 to string if needed.

Returns a new string that is the concatenation of the two.

Result is always a string. So A is valid.

Option B:

String.concat(var1 + var2)

String.concat (as a static method) does not exist. concat is an instance method on string objects, not on the String constructor.

var1 + var2 might be a number (if both numeric) and used incorrectly here. So B is invalid.

Option C:

var1 + var2

+ can mean:

String concatenation (if at least one operand is a string).

Numeric addition (if both operands are numbers).

If var1 and var2 are both numbers, var1 + var2 will be a number, not a string.

This does not ensure the result is always a string. So C is not guaranteed to satisfy the requirement.

Option D:

var1.toString() + var2.toString()

var1.toString() converts var1 to a string (for most primitive/object types).

var2.toString() does the same.

Now both operands of + are strings, so the result is string concatenation.

Result is guaranteed to be a string. So D is valid.

Therefore, the two valid ways are A and D.

Study Guide / Concept References (no links):

String() conversion vs .toString()

String.prototype.concat

+ operator overload: numeric addition vs string concatenation

Type coercion rules for primitives

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 answer is B because JavaScript uses lexical scope .

When a function is created inside another function, the inner function can access variables from the outer function where it was defined.

For example:

function first() {

let a = 10;

function second() {

console.log(a);

}

second();

}

Here, a belongs to the outer function first(). The inner function second() can access it because JavaScript looks for variables through the scope chain.

The lookup works like this:

1. Look inside second()

2. If not found, look inside first()

3. If not found, look in the global scope

Since a is found in the outer function’s scope, second() can use it.

This is also the basis of a closure . A closure allows an inner function to remember and access variables from its outer lexical environment.

Why the other options are incorrect:

A is not the best answer because a is not declared inside second() itself.

C is incorrect because the prototype chain is used for object property lookup, not local variable scope lookup.

D is incorrect because hoisting explains how declarations are moved during compilation, but it does not explain why an inner function can access an outer function’s variable.

Therefore, the verified answer is B .

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 .

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.

JavaScript defines two main page-loading events:

DOMContentLoaded Fires when the HTML document has been completely parsed. External resources like images, stylesheets, iframe contents, etc. may not be loaded yet .

load event on window Fires when:

HTML is fully parsed

All dependent resources (images, scripts, CSS, fonts, etc.) are fully loaded

The requirement states:

“when the webpage is fully loaded (HTML content and all related files )”

This aligns exactly with the window load event .

Implementation:

window.addEventListener( " load " , personalizeWebsiteContent);

This matches option B.

JavaScript knowledge references (text-only)

DOMContentLoaded fires after HTML parsing only.

load fires after all page resources finish loading.

The window object is the correct target for listening to the full load event.

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

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.