Salesforce JavaScript-Developer-I Salesforce Certified JavaScript Developer (JS-Dev-101) Exam Practice Test

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.

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.

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

To select an element by ID, JavaScript uses:

document.getElementById( " status " )

The ID must be passed without any selector prefixes (no dot, no hash).

Then, to update the text inside:

element.innerHTML = ' Completed ' ;

Why the others are wrong:

A uses " .status " which would match a CSS class, not an ID.

B incorrectly prepends #, which is used in CSS selectors but not in getElementById.

D attempts to use .Value with capital V, which is incorrect for DOM text; .value only applies to form elements.

Thus, option C is correct.

JavaScript Knowledge References (text-only)

getElementById takes a raw ID string with no prefixes.

innerHTML updates an element’s displayed HTML content.

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

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

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.

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

Step-by-step:

Synchronous code first:

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

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

Lines 05–09: Construct a new Promise.

The executor runs immediately.

Inside it, another setTimeout is set for 1000 ms:

setTimeout(() = > {

reject(console.log(3));

}, 1000);

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

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

So after all synchronous code, the console has:

2

5

At 1000 ms: inner setTimeout fires

The callback:

() = > {

reject(console.log(3));

}

Inside:

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

console.log(3) returns undefined.

Then reject(undefined) is called.

So at about 1000 ms, we log:

3

When the promise is rejected:

The .catch handler is scheduled as a microtask .

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

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

So immediately after 3, the catch handler logs:

4

Now the logs in order are:

2

5

3

4

At 1100 ms: outer setTimeout fires

The callback from line 01 runs:

console.log(1);

Logs: 1.

Final log order:

2 (line 4, sync)

5 (line 12, sync)

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

4 (promise catch microtask after rejection)

1 (1100 ms timeout)

Concatenated: 25341.

Therefore, the correct option is:

Answer: A

Study Guide / Concept References (no links):

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

setTimeout scheduling and ordering

Promise rejection, .catch, and microtasks

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

Definitions:

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

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

True positive → Correctly identifies something is working.

True negative → Correctly identifies something is not working.

In this scenario:

The checkout button does exist , so the feature works.

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

That is the definition of a false negative .

JavaScript Knowledge References (text-only)

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

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

The correct 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 .

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

setTimeout(functionReference, delayInMilliseconds)

Characteristics of setTimeout():

Executes only once .

Delay is specified in milliseconds.

Requires passing the function reference , not calling the function.

Two minutes is:

2 minutes = 120 seconds = 120,000 milliseconds

Now evaluate each option:

Option A: delay(sayHello, 120000);

Incorrect.

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

Option B: setTimeout(sayHello, 120000);

Correct.

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

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

Incorrect.

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

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

Option D: setInterval(sayHello, 120000);

Incorrect.

setInterval() repeats execution every 120,000 ms.

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

JavaScript Knowledge References (text-only)

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

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

setInterval() repeats indefinitely, unlike setTimeout().

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

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

New behavior: sum3 now returns the sum of all elements .

Line 01: sum3([1, 2, 3]) → 1 + 2 + 3 = 6

Assertion on line 02: res === 6 → passes.

Line 04: sum3([1, 2, 3, 4]) → 1 + 2 + 3 + 4 = 10

Assertion on line 05: res === 6 → 10 === 6 is false, so the assertion fails.

So:

Line 02 assertion passes → D.

Line 05 assertion fails → C.

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 .

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.

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

You then call:

lib.foo();

lib.bar();

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

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

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

userInformation is a plain JavaScript object:

{

id: " user-01 " ,

email: " user01@universalcontainers.demo " ,

age: 25

}

You can access object properties in two standard ways:

Dot notation : object.propertyName

Bracket notation : object[ ' propertyName ' ]

Apply to each option:

A. userInformation.email

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

B. userInformation.get( " email " )

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

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

C. userInformation[ " email " ]

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

Returns " user01@universalcontainers.demo " .

D. userInformation[email]

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

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

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

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

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

Therefore, the correct ways are:

Answer: A, C

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

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

The verified answer is A .

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

function Person() {

this.firstName = " John " ;

}

So this line:

const myFather = new Person();

creates an object like this:

{

firstName: " John "

}

Then the prototype is assigned a method named job:

Person.prototype = {

job: x = > " Developer "

};

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

So:

myFather.firstName

returns:

" John "

And:

myFather.job()

returns:

" Developer "

Therefore:

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

becomes:

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

Final value:

" John Developer "

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

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

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

Therefore, the verified answer is A .

The correct answer is D .

Semantic versioning usually follows this format:

MAJOR.MINOR.PATCH

For the version:

1.1.3

The parts are:

1 = MAJOR

1 = MINOR

3 = PATCH

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

MAJOR version changes when there are breaking changes.

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

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

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

Starting version:

1.1.3

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

1.2.0

Why the other options are incorrect:

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

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

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

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

Therefore, the verified answer is D .

Node.js provides two built-in modules for creating servers:

http → creates non-secure HTTP servers

https → creates secure HTTPS servers

A secure server requires:

SSL/TLS certificates (key and cert)

The built-in Node.js module designed to handle these: https

Syntax for a secure server:

const https = require( ' https ' );

const fs = require( ' fs ' );

const options = {

key: fs.readFileSync( ' key.pem ' ),

cert: fs.readFileSync( ' cert.pem ' )

};

https.createServer(options, (req, res) = > {

res.write( ' Secure Server ' );

res.end();

}).listen(443);

Evaluation of options:

A is incorrect: No built-in module named secure-server exists.

B is incorrect: tls provides low-level TLS sockets, not HTTP/HTTPS servers.

C is incorrect: http only creates an insecure server.

D is correct: https is the built-in module required for secure web servers.

JavaScript Knowledge References (text-only)

Node.js exposes built-in modules http and https for server creation.

Secure servers require the https module, which supports TLS/SSL.

The tls module is lower-level and not used for full HTTP servers.

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

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.

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.

Comprehensive and Detailed Explanation:

Evaluate step by step:

' 15 ' + 10

+ with a string operand performs string concatenation.

10 is coerced to ' 10 ' .

Result: ' 1510 ' .

' 1510 ' * 2

* always performs numeric multiplication.

' 1510 ' is converted to the number 1510.

1510 * 2 = 3020.

So x is 3020.

objA is created with:

{ value: 10 }

objB = objA; Objects in JavaScript are assigned by reference , not copied. So objA and objB refer to the same object in memory.

The function:

changeValue(obj) {

obj.value = obj.value / 2;

}

When called as changeValue(objB), it updates the value property of the shared object :

value = 10 / 2 → 5

Therefore:

objA.value === 5

Because objA and objB refer to the same object, the change is reflected in both.

JavaScript Knowledge References (text-only)

Objects are stored and passed by reference.

Mutating an object inside a function mutates the original object.

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

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 .

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 .

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

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)

Promise.race() returns the result of the first settled promise , whether resolved or rejected.

The promises:

car1 → rejects in 2000 ms

car2 → resolves in 1500 ms

car3 → resolves in 3000 ms

The earliest settled promise is car2 (1500 ms), which resolves with the value:

" Car 2 completed "

Therefore, Promise.race enters the .then() branch with:

value = " Car 2 completed "

Inside the .then():

let result = ' $(value) the race. ' ;

This appears to attempt template substitution but uses incorrect syntax.

JavaScript template literals require backticks and ${expression}, for example:

`${value} the race.`

Because the code is incorrect, result is literally the string:

$(value) the race.

However, the question asks:

“What is the value of result when Promise.race executes ?”

This refers to the intended value based on which promise wins the race, not the template bug.

The winning value is:

Car 2 completed

So the correct conceptual answer is:

Car 2 completed the race.

JavaScript Knowledge References (text-only)

Promise.race() returns the first settled (resolved or rejected) promise.

The earliest resolve here is car2 (1500 ms).

Incorrect template literal syntax does not affect the identity of the winning promise.

Recall:

NaN stands for “Not-a-Number”.

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

Check each:

A. 10 / 0

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

So this logs Infinity.

B. parseInt( ' two ' )

parseInt tries to parse a numeric prefix from the string.

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

The console log prints NaN.

C. 10 / Number( ' 5 ' )

Number( ' 5 ' ) → 5.

10 / 5 → 2.

Logs 2, not NaN.

D. 10 / ' five '

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

10 / NaN → NaN.

Logs NaN.

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

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

The correct answer is 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 answer is C .

When getAvailability(item) returns true, the code inside the if block executes:

var msg = " Username available " ;

return msg;

The variable msg receives the string value:

" Username available "

Then that same value is returned from the function.

The key point is that var is function-scoped, not block-scoped. So msg belongs to the function scope of getAvailabilityMessage(). However, because the return msg; statement is inside the same if block, the function immediately returns the assigned string when the username is available.

Option A is incorrect because msg is defined before it is returned.

Option B is incorrect because " newUserName " is not assigned or returned anywhere in the function.

Option D would only happen if getAvailability(item) returned false, because then the function would finish without an explicit return value.

For the available username scenario, the verified answer is C .

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

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

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

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

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

Object.assign(leo, tony);

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

Why the other answers are incorrect:

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

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

JavaScript Knowledge References (text-only)

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

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

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

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

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.

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

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.

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 answer is C .

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

event.stopPropagation();

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

A click event normally goes through these phases:

Capturing phase → Target phase → Bubbling phase

Because the event listener is attached to the button:

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

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

Corrected code:

< html >

< body >

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

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

< /body >

< script >

function printMessage(event) {

event.stopPropagation();

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

}

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

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

< /script >

< /html >

Why this is correct:

event.stopPropagation();

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

Why the other options are incorrect:

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

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

printMessage(event)

Therefore, the verified answer is C .

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

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

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 constructor signature for CustomEvent is:

new CustomEvent(eventName, optionsObject)

Where:

eventName is a string.

optionsObject may include:

detail → used to pass custom data

bubbles

cancelable, etc.

Example:

new CustomEvent( ' update ' , {

detail: { recordId: ' 123abc ' }

});

Now evaluate each option:

Option A

{ type: ' update ' , recordId: ' 123abc ' }

Incorrect: The constructor requires (eventName, options), not a single object. type is not used this way.

Option B

' update ' , { detail: { recordId: ' 123abc ' } }

Correct format. detail is the proper place for custom event data.

Option C

' update ' , ' 123abc '

Incorrect: The second argument must be an object (options), not a string.

Option D

' update ' , { recordId: ' 123abc ' }

Acceptable because any extra properties on the options object are still allowed, even though best practice is to use detail.

This still creates a valid CustomEvent, and the event will dispatch successfully.

Thus the two correct answers are B and D .

JavaScript Knowledge References (text-only)

new CustomEvent(name, options) is the required syntax.

The detail property of the options object is the standard location for custom data.

The second argument must be an object; other types are invalid.

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 .

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

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