Free Practice Questions for the Salesforce Developer JavaScript-Developer-I Exam (2026 Updated)

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.

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

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.

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

The syntax:

import printPrice from ' module ' ;

means the module must export its function as a default export :

export default function printPrice() { ... }

Why the others are wrong:

Named exports require curly braces:

import { printPrice } from ' module ' ;

“all export” and “multi export” are not JavaScript terms.

Therefore, printPrice must be the default export .

JavaScript Knowledge References (text-only)

Default imports use: import name from ' module ' .

Named imports require braces: import { name } from ' module ' .

First, compute sampleText:

let codeName = ' Bond ' ;

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

The template literal evaluates to:

" The name is Bond, Jim Bond "

Now evaluate each statement:

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

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

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

So this returns true.

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

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

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

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

So this returns false.

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

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

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

This returns true.

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

String.prototype.indexOf(substring) returns:

-1 if the substring is not found,

Otherwise, the starting index of the first occurrence.

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

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

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

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

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

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

Number( ' Jim ' ) → NaN

NaN for startIndex is treated as 0.

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

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

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

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

Answer: A, C, D

Study Guide / Concept References (no links):

Template literals and ${} interpolation

String.prototype.includes(searchString, position?)

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

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

Boolean vs non-boolean return types in string methods

When pet1 = new Pet(); is created:

Inside Pet constructor:

Animal.call(this, size, type);

this.size = size;

this.name = name;

this.owner = owner;

Animal.call(this, size, type):

Sets this.type = type || ' Animal ' → ' Animal ' (because type is undefined).

Sets this.canTalk = false.

Then this.size, this.name, this.owner are set (to undefined since no args passed), but they do exist as properties .

So as own properties, pet1 has: type, canTalk, size, name, owner.

speak is defined on Animal.prototype, so pet1.speak exists by inheritance, but is not an own data property created in the constructor.

From the listed options, three important properties directly set by constructor logic and clearly used in behavior are:

canTalk

name

type

Thus, C, D, E.

The code:

let timerId = setInterval(timedFunction, 1000);

setInterval schedules timedFunction to run every 1000 ms.

It returns an interval ID (here stored in timerId), which is used to cancel the interval later.

To cancel:

Use clearInterval(timerId);

This is the standard browser (and Node.js) API:

let id = setInterval(fn, delay);

clearInterval(id); stops future executions of that interval.

Check other options:

B. removeInterval(timerId);

There is no removeInterval function in the standard JavaScript timer API.

C. removeInterval(timedFunction);

Again, no such function; and timers are cancelled by ID, not by the callback function reference.

D. clearInterval(timedFunction);

clearInterval expects the ID returned by setInterval, not the callback function.

Passing the function does not cancel the timer.

Therefore, the correct statement is:

Answer: A

Study Guide / Concept References (no links):

Timer APIs: setInterval and clearInterval

Relationship between timer ID and cancellation

Difference between interval ID and callback function

Basic async timing patterns in JavaScript

Initial array:

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

The loop removes every value equal to 4:

array.splice(i, 1) removes the element at index i and shifts all later elements left.

i-- ensures the next index is checked correctly after the shift, preventing skipping elements.

Step-by-step removal:

Remove the first 4 → array becomes [1,2,3,4,5,4,4]

Remove next 4 → [1,2,3,5,4,4]

Remove next 4 → [1,2,3,5,4]

Remove last 4 → [1,2,3,5]

Final result:

[1,2,3,5]

Option B is correct.

JavaScript Knowledge References (text-only)

splice(index, deleteCount) removes elements and shifts remaining items.

Adjusting the loop index when deleting prevents skipping items.

Arrays update length dynamically after splice().

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:

Assuming SaleItem inherits from Item via prototype (e.g. SaleItem.prototype = Object.create(Item.prototype)):

Lines 01–02: create regItem and saleItem.

Line 03: define Item.prototype.description.

Now both regItem and saleItem (via inheritance) have a description method from Item.prototype.

Line 04: regItem.description() → ' This is a Scarf ' .

Line 05: saleItem.description() → ' This is a Shirt ' (same method, but this.name is ' Shirt ' ).

Line 07: SaleItem.prototype.description = ... overrides description only for SaleItem instances going forward.

If we imagine calling regItem.description() and saleItem.description() again after line 07:

regItem.description() still uses Item.prototype.description → ' This is a Scarf ' .

saleItem.description() now uses SaleItem.prototype.description → ' This is a discounted Shirt ' .

Those four lines correspond to option B.

Semantic versioning: MAJOR.MINOR.PATCH

MAJOR: incompatible API changes.

MINOR: add functionality in a backward compatible manner.

PATCH: backward compatible bug fixes.

Here:

Bug fixes only, no breaking changes → increment PATCH.

From 2.1.1 to 2.1.2.

So the correct new version is 2.1.2.

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.

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

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.

Arrow functions have two defining characteristics:

Implicit return when written as a single expression:

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

This is unique to arrow functions → A is correct.

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

Incorrect options:

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

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

JavaScript Knowledge References (text-only)

Arrow functions have lexical this binding.

Arrow functions support implicit return for single expressions.

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

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.

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 .

In JavaScript, when calling a constructor function without new:

const m = Monster();

the following happens:

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

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

In a browser: window

So the line:

this.name = ' hello ' ;

becomes:

window.name = ' hello ' ;

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

const m = undefined;

Therefore:

m is undefined

window.name becomes " hello "

This matches option B .

JavaScript Knowledge References (text-only)

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

Constructor functions must use new to create a new object.

Functions without an explicit return return undefined.

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.

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 .

Two key browser events:

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

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

The requirement states:

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

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

So the correct code is:

window.addEventListener( ' load ' , personalizeWebsiteContent);

Why others are incorrect:

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

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

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

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

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

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

Person instances have:

firstName and lastName as string properties.

A name method that returns a combined string: `${this.firstName},${this.lastName}`.

Object.assign({}, john) creates a shallow copy of john into a new object, dan.

After:

dan.firstName = ' Dan ' ;

dan.name() returns " Dan,Doe " .

Analysis of options:

A: dan.firstName() and dan.lastName() are function calls , but firstName/lastName are strings, not functions → TypeError.

B: Calls the defined method and uses both names correctly.

C: dan.name is a function reference; you’d still need to call it: dan.name().

D: dan.firstName + dan.lastName is " DanDoe " , no separator. It accesses the properties but not in the method the developer defined.

The intended way, using the provided API, is dan.name().

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.

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.

Current behavior:

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

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

So " Table log " never appears.

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

Remove the propagation stop:

function printMessage(event) {

console.log( ' Row log ' );

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

}

Now the event bubbles:

printMessage logs " Row log " .

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

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

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 .

JSON.stringify() applies the following rules:

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

new String( " false " ) → " false "

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

new Boolean(false) → false

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

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

Therefore, the array becomes:

[ " false " , false, null]

And JSON.stringify wraps it in quotes:

' [ " false " , false, null] '

This is exactly option A.

JavaScript Knowledge References (text-only)

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

undefined becomes null inside arrays when stringified.

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

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

The function:

async function functionUnderTest(isOK) {

if (isOK) return ' OK ' ;

throw new Error( ' not OK ' );

}

Behavior:

If isOK is true:

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

If isOK is false:

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

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

Key points about console.assert:

Signature: console.assert(condition, message?)

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

If condition is truthy , nothing is logged.

We also must understand await:

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

Now evaluate options.

Option A:

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

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

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

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

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

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

Uses await properly on the async function, and

Associates the message with the expected success " OK " .

Option B:

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

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

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

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

The expression evaluates to the string ' not OK ' .

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

console.assert( ' not OK ' );

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

This does not meaningfully test the function and is misleading.

Option C:

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

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

A Promise object is always truthy.

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

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

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

Option D:

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

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

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

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

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

Therefore, the only assertion that:

Properly waits on the async function, and

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

is:

Answer: A

Study Guide / Concept References (no links):

async and await behavior in JavaScript

Promises resolving vs rejecting in async functions

console.assert(condition, message) usage

Truthy and falsy values in JavaScript

Comma operator (a, b) semantics

console.assert(condition, message?) logs an assertion error if condition is falsy.

To log an error when number + 2 === 0 is false, use:

console.assert(number + 2 === 0);

Other options are invalid or do not behave as described: console.error always logs, assert alone is not a built-in browser global, and console.classy doesn’t exist.

Behavior of Promise.prototype.finally:

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

Either fulfilled (resolved) , or

rejected .

Important points:

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

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

It runs in both success and failure paths.

In the given code:

The promise may either:

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

Call resolve(fraction) otherwise.

In both cases:

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

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

So .finally runs:

Not just “when rejected”.

Not just “when resolved”.

But whenever the promise is resolved or rejected .

Therefore, the correct choice is:

D. When resolved or rejected .

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.

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.

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.

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 .

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

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

The important clue is this third argument:

addEventListener( ' click ' , handlerFunction, true);

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

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

Outer element → Inner element

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

That produces:

Outer message

Inner message

So the matching option is B .

Important correction:

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

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

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

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

Clicking the secondary button logs:

Save message.

Clicking the primary button logs:

Success message.

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

Outer message

Inner message

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

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.

Person.proto is being set, but JavaScript uses Person.prototype for the prototype chain, not Person.proto.

Therefore, job is not on Person.prototype, and instances of Person do not have job via prototype.

myFather is created with new Person(), so:

myFather.firstName is ' John ' .

myFather.job is undefined.

Attempting to call myFather.job() results in:

TypeError: myFather.job is not a function

So option A is correct.

The key line is:

for (let something of obj) {

In JavaScript:

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

Arrays

Strings

Maps

Sets

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

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

Specifically:

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

will throw a TypeError similar to:

obj is not iterable

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

Why other options are incorrect:

B. [1, 2]

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

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

C. [ " foo " , " bar " ]

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

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

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

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

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

Hence, the correct answer is:

Answer: A

Study Guide / Concept References (no links):

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

Iterables in JavaScript and [Symbol.iterator]

Plain objects {} are not iterable by default

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