JavaScript-Developer-I Salesforce Certified JavaScript Developer (JS-Dev-101) Free Practice Exam Questions (2026 Updated)

The verified answer is C .

This object has two properties:

let obj = {

foo: 1,

bar: 2

};

The property names are:

foo

bar

The property values are:

1

2

The loop used here is a for...in loop:

for (let something in obj) {

output.push(something);

}

A for...in loop iterates over the property keys of an object, not the property values.

So during the first iteration:

something === " foo "

The code pushes " foo " into the array.

During the second iteration:

something === " bar "

The code pushes " bar " into the array.

The final value of output is:

[ " foo " , " bar " ]

That is why:

console.log(output);

prints:

[ " foo " , " bar " ]

Option B would be correct only if the code pushed the values, for example:

output.push(obj[something]);

Option D would require building formatted strings manually, such as:

output.push(`${something}:${obj[something]}`);

But the given code only pushes the property names.

Therefore, the verified answer is C .

JavaScript defines two main page-loading events:

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

load event on window Fires when:

HTML is fully parsed

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

The requirement states:

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

This aligns exactly with the window load event .

Implementation:

window.addEventListener( " load " , personalizeWebsiteContent);

This matches option B.

JavaScript knowledge references (text-only)

DOMContentLoaded fires after HTML parsing only.

load fires after all page resources finish loading.

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

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

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

{

" scripts " : {

" start " : " node server.js "

}

}

Then you start the app with:

npm start

npm start:

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

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

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

Why others are incorrect:

A. node start

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

C. npm start server.js

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

D. start server.js

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

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

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

When a module contains multiple functions and each function should be available individually, the best choice is a named export .

Example:

function add(a, b) {

return a + b;

}

function subtract(a, b) {

return a - b;

}

export { add, subtract };

Then another file can import exactly the functions it needs:

import { add, subtract } from ' ./mathUtils.js ' ;

console.log(add(5, 2));

console.log(subtract(5, 2));

Named exports are useful when a module provides several reusable functions, constants, or classes.

Why the other options are incorrect:

multi is not a JavaScript export type.

default is usually used when a module has one main value to export. A module can only have one default export.

all is not an export type in JavaScript module syntax.

Therefore, the correct export type for multiple functions is named export , so the verified answer is D .

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.

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

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.

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.

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

Understand the three promises:

car1:

let car1 = new Promise((_, reject) = >

setTimeout(reject, 2000, " Car 1 crashed in " )

);

Rejects after 2000 ms (2 seconds) with message " Car 1 crashed in " .

car2:

let car2 = new Promise(resolve = >

setTimeout(resolve, 1500, " Car 2 completed " )

);

Resolves after 1500 ms (1.5 seconds) with message " Car 2 completed " .

car3:

let car3 = new Promise(resolve = >

setTimeout(resolve, 3000, " Car 3 completed " )

);

Resolves after 3000 ms (3 seconds) with message " Car 3 completed " .

Promise.race:

Promise.race([car1, car2, car3])

then(value = > {

let result = `${value} the race.`;

})

catch(err = > {

console.log( " Race is cancelled. " , err);

});

Behavior of Promise.race:

It settles (resolves or rejects) as soon as any of the given promises settles.

It uses the value or reason from the first settled promise.

Timing:

car2 resolves in 1500 ms.

car1 rejects in 2000 ms.

car3 resolves in 3000 ms.

The first to settle is car2 at 1500 ms, with value " Car 2 completed " .

Therefore:

Promise.race resolves (not rejects) with value = " Car 2 completed " .

The .then handler runs; .catch is ignored because there is no rejection.

Inside .then:

let result = `${value} the race.`;

Substitute value:

let result = " Car 2 completed the race. " ;

So, result becomes:

Car 2 completed the race.

Compare to options:

A. Car 3 completed the race.

This would be correct if car3 were the first to resolve, which it is not (it resolves last).

B. Car 2 completed the race.

Exactly matches the first-resolving promise and the constructed message.

C. Race is cancelled.

This is the prefix of the string logged in the .catch handler, but .catch never runs because the race resolves, it does not reject first.

D. Car 1 crashed in the race.

car1 is the first rejection , but since a resolution from car2 happens earlier, the race is already settled successfully before car1 rejects.

Thus the correct value of result as set in the .then block is:

Answer: B

Study Guide / Concept References (no links):

Promise.race(iterable) semantics (first settled promise wins)

setTimeout and timing interactions with Promises

Resolve vs reject paths and .then / .catch

Template literals and string interpolation for building result messages

We want:

const addByEight = addBy(8);

const sum = addByEight(50);

And we need sum to be 58.

That means:

addBy(8) must return a function.

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

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

Option A

const addBy = function(num1) {

return function(num2) {

return num1 + num2;

}

}

Step-by-step:

Call addBy(8):

num1 is 8.

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

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

Then call addByEight(50):

num2 is 50.

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

Therefore, with Option A in place:

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

const sum = addByEight(50); // 58

So sum is 58. Option A is correct.

Option D (corrected)

const addBy = (num1) = > {

return function(num2) {

return num1 + num2;

}

}

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

Call addBy(8):

num1 is 8.

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

Call addByEight(50):

num2 is 50.

Computes num1 + num2 → 8 + 50 = 58.

So again:

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

const sum = addByEight(50); // 58

Option D is also correct.

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

Why B and C are incorrect

Option B:

const addBy = function(num1) {

return num1 * num2;

}

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

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

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

Option C:

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

Again, addBy returns a value, not a function.

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

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

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

References / Study Guide concepts (no links):

Higher-order functions in JavaScript

Closures: inner functions capturing outer variables (num1)

Arrow functions vs function expressions

Returning functions from functions (function factories / currying)

Scope and ReferenceError when a variable is not defined

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.

Evaluate each test:

A. sum3([1, ' 2 ' ])

Array length is 2 → line 4: arr[0] + arr[1] → 1 + ' 2 ' → ' 12 ' (string).

Assertion: ' 12 ' == 12 is true (type coercion). However, this “test” is not logically correct: a numeric sum function should not be expected to return ' 12 ' as a string. It passes only because of weak equality coercion, so it is not a good/valid test of correct behavior.

B. sum3([ ' hello ' , 2, 3, 4])

Length ≥ 3 → line 5: ' hello ' + 2 + 3 → ' hello2 ' + 3 → ' hello23 ' .

' hello23 ' === NaN is always false because NaN is never equal to anything, not even itself. This assertion fails and also misunderstands how NaN comparisons work.

C. sum3([-3, 2])

Length 2 → -3 + 2 = -1.

Assertion: -1 === -1 → true. This is a correct and meaningful test.

D. sum3([0])

Length 1 → returns arr[0] → 0.

Assertion: 0 === 0 → true. Also a correct and meaningful test.

Therefore, the valid and logically correct tests here are C and D.

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

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.

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.

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

String: " Yay! Salesforce is amazing! "

Index positions:

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

Substring " Sales " starts at index 5.

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

searchText.search(/sales/i);

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

It matches " Sales " beginning at index 5.

So result1 is 5.

searchText.search(/sales/);

/sales/ is case-sensitive.

It requires lowercase " sales " .

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

search returns -1 when there is no match.

So result2 is -1.

Console output:

First log: 5

Second log: -1

Option D matches this.

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

JavaScript has one numeric data type for all real numbers, whether integers or decimals.

This type is simply called:

Number

It follows the IEEE 754 double-precision floating-point standard internally,

but JavaScript does not expose separate types like float, double, or decimal.

Therefore:

It is not Float → JavaScript does not have float primitives.

It is not Double → this refers to the underlying IEEE 754 representation, but JavaScript ' s type is still just “Number.”

It is not Decimal → JavaScript has no built-in decimal type.

The correct answer is Number .

JavaScript Knowledge References (text-only)

JavaScript has a single numeric type: Number.

All numbers—integers, fractions, floating point—use the Number type.

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

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

Option A:

String(var1).concat(var2)

String(var1) converts var1 explicitly to a string.

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

Converts var2 to string if needed.

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

Result is always a string. So A is valid.

Option B:

String.concat(var1 + var2)

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

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

Option C:

var1 + var2

+ can mean:

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

Numeric addition (if both operands are numbers).

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

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

Option D:

var1.toString() + var2.toString()

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

var2.toString() does the same.

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

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

Therefore, the two valid ways are A and D.

Study Guide / Concept References (no links):

String() conversion vs .toString()

String.prototype.concat

+ operator overload: numeric addition vs string concatenation

Type coercion rules for primitives