Free Practice Questions for Salesforce JavaScript-Developer-I Exam

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

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

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

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

In strict mode: this would throw a TypeError.

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

Therefore, the object remains:

{ title: " JavaScript " }

Both objBook and newObjBook point to the same unchanged object.

This matches option A.

JavaScript knowledge references (text-only)

Object.preventExtensions() prevents adding new properties.

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

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

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

A subclass created by:

Console16bit.prototype = Object.create(GameConsole.prototype);

inherits all prototype methods from GameConsole, including load.

To override the inherited method, the correct syntax is to assign a new function to the method name on the prototype:

Console16bit.prototype.load = function(gamename) {

console.log(`${this.name} is loading a cartridge game: ${gamename}....`);

};

Why the other options are wrong:

A assigns something to the constructor function itself, not to the prototype method. Invalid.

B attempts to call a function in the left-hand side of an assignment; invalid syntax.

C also uses invalid syntax—prototype methods cannot be defined this way.

D is the correct definition of a prototype method override.

JavaScript Knowledge References (text-only)

Methods are overridden by assigning functions to Subclass.prototype.methodName.

Object.create() establishes prototype inheritance.

Constructor functions require prototype method attachment using assignment syntax.

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

The correct answers are A, B, and D .

The two variables are:

let str1 = ' Java ' ;

let str2 = ' Script ' ;

The goal is to combine them into:

JavaScript

Option A is correct because template literals can insert variables directly into a string:

`${str1}${str2}`

This becomes:

`${ ' Java ' }${ ' Script ' }`

Result:

JavaScript

Option B is correct because strings have a concat() method:

str1.concat(str2);

This joins str2 onto the end of str1.

Result:

JavaScript

Option D is correct because the + operator performs string concatenation when both operands are strings:

str1 + str2;

This becomes:

' Java ' + ' Script '

Result:

JavaScript

The incorrect options:

Option C is not valid JavaScript for joining strings. const is used for declaring constants, not concatenating values.

Option E is incorrect because join() is an array method, not a string method. This would only work with an array, for example:

[ ' Java ' , ' Script ' ].join( ' ' );

But str1 is a string, so:

str1.join(str2)

is invalid.

Therefore, the verified answers are A, B, and D .

Requirement:

The message should be displayed only on the first click of the button.

Original behavior:

The handler listen is attached with button.addEventListener( ' click ' , listen);.

That means listen is called on every click until the listener is removed or configured otherwise.

Two correct ways to ensure the listener only fires once:

Use the once option in addEventListener

Remove the event listener after the first run inside the handler

Option C:

On line 06, add an option called once to button.addEventListener().

This means modifying line 06 to:

button.addEventListener( ' click ' , listen, { once: true });

The once: true option tells the browser:

Call the listen function at most once.

After it is called the first time, automatically remove the listener.

So:

First click: alert shows, listener is removed automatically.

Subsequent clicks: no further calls to listen, no alerts.

This satisfies the requirement.

Option D:

On line 04, use button.removeEventListener( ' click ' , listen);

This means updating the handler:

function listen(event) {

alert( ' Hey! I am John Doe ' );

button.removeEventListener( ' click ' , listen);

}

Now:

On the first click, listen is executed:

It shows the alert.

It removes itself from the button’s click listeners.

On subsequent clicks, listen is no longer registered, so nothing happens.

This also satisfies the requirement.

Why A and B are incorrect:

Option A:

On line 04, use event.stopPropagation();

event.stopPropagation() stops the event from bubbling up the DOM tree.

It does not prevent the current listener from being called again in the future.

The click handler will still run on every click; it just prevents other listeners higher in the DOM from receiving the event.

Option B:

On line 02, use event.first to test if it is the first execution.

There is no built-in event.first property in standard DOM events.

This property does not exist and will be undefined.

You would need your own external flag (let hasRun = false;) to track first execution, but that is not what B describes.

Therefore, the two correct modifications are:

Answer: C, D

Study Guide / Concept References (no links):

addEventListener options object: { once: true }

removeEventListener to manually deregister event handlers

Event propagation (event.stopPropagation) vs handler lifecycle

DOM event model and listener registration

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 .

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.

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 .

We start with the array:

let inArray = [ [1, 2], [3, 4, 5] ];

This is an array of two inner arrays:

First element: [1, 2]

Second element: [3, 4, 5]

The desired result is to transform this into a single, flat array:

[1, 2, 3, 4, 5]

This is accomplished by using Array.prototype.concat to concatenate the inner arrays into one new array, optionally combined with the spread syntax (...) or Function.prototype.apply.

Option A: [].concat(...inArray);

Relevant concepts:

Spread syntax (...inArray) expands an iterable into separate arguments.

Array.prototype.concat joins arrays or values into a new array. When you pass arrays as arguments to concat, it flattens them one level into the result.

Step-by-step behavior:

inArray is [ [1, 2], [3, 4, 5] ].

...inArray expands into [1, 2] and [3, 4, 5] as separate arguments.

So [].concat(...inArray) is equivalent to:

[].concat([1, 2] , [3, 4, 5]);

concat processes each argument:

For [1, 2], it adds 1 and 2 into the result array.

For [3, 4, 5], it adds 3, 4, and 5 into the result array.

The final outcome is:

[1, 2, 3, 4, 5]

Therefore, Option A correctly produces the desired array.

Option B: [].concat.apply(inArray, [] );

Corrected name from usArray to inArray.

Relevant concepts:

Function.prototype.apply(fnThis, argsArray) invokes a function with a specific this value and a list of arguments passed as an array.

Here:

thisArg is inArray.

argsArray is [] (no actual arguments passed).

So the call:

[].concat.apply(inArray, [] );

is equivalent to:

Array.prototype.concat.apply(inArray, []);

// i.e. inArray.concat();

Since there are no extra arguments, inArray.concat() simply returns a shallow copy of inArray:

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

This remains an array of arrays and is not flattened into [1, 2, 3, 4, 5]. Therefore, Option B does not produce the required result.

Option C: [].concat::...inArray();

Corrected name from usArray to inArray and .. to ....

This expression uses syntax that is not part of standard JavaScript:

:: (double colon) was proposed in early drafts as a bind operator but is not part of the official ECMAScript standard.

The combination concat::...inArray() is invalid in normal JavaScript engines and cannot be used as a valid way to flatten arrays.

In addition, inArray() would imply calling inArray as a function, but it is an array, which would cause a runtime error.

Hence, Option C is syntactically or semantically invalid in standard JavaScript and does not provide the required result [1, 2, 3, 4, 5].

Option D: [].concat.apply({}, inArray);

Corrected name from usArray to inArray.

Relevant concepts:

Again, Function.prototype.apply is used to call concat with a specific this value and arguments provided as an array.

concat treats its this value as an array-like object but ultimately returns a new array containing concatenated elements.

In this expression:

[].concat.apply({}, inArray);

thisArg is {} (an empty object).

argsArray is inArray, which is [ [1, 2], [3, 4, 5] ].

Using apply, this is interpreted as calling concat like:

Array.prototype.concat.call({}, [1, 2], [3, 4, 5] );

concat then:

Starts from the array-like this (here {} is treated as an empty base).

Takes the first argument [1, 2] and appends its elements 1 and 2 to the result.

Takes the second argument [3, 4, 5] and appends its elements 3, 4, and 5 to the result.

The resulting new array is:

[1, 2, 3, 4, 5]

Therefore, Option D also correctly produces the required array.

Final evaluation of all options:

Option A: Uses spread syntax with concat and correctly flattens one level: [1, 2, 3, 4, 5].

Option B: Equivalent to inArray.concat(), leaving it as [[1, 2], [3, 4, 5]] . Does not flatten the structure.

Option C: Uses non-standard and invalid syntax; not a valid or correct JavaScript solution.

Option D: Uses apply with concat, passing the inner arrays as arguments and flattening one level to [1, 2, 3, 4, 5].

Thus, the two correct statements are:

Answer: A, D

References of JavaScript knowledge documents or Study Guide (concept names only):

Array.prototype.concat (concatenating and one-level flattening behavior)

Spread syntax for arrays (...array)

Function.prototype.apply (calling a function with a given this value and arguments list)

Array flattening by one level using concat with array arguments

Distinction between nested arrays and flat arrays in JavaScript

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

node inspect server.js

This:

Starts server.js under the Node.js inspector.

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

Lets you interactively:

Step through code

Set breakpoints

Inspect variables

Continue execution, etc.

Why B is correct:

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

It does not rely on any external GUI tools.

You stay entirely in the terminal to debug.

Why the other options are incorrect:

A. node start inspect server.js

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

This is not a valid Node.js debugging command.

C. node server.js --inspect

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

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

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

D. node -i server.js

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

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

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

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

Answer: B

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

Node.js CLI debugger: node inspect < script >

Node.js inspector protocol: node --inspect

Difference between CLI debugger and DevTools-based debugging

Node.js command-line options and subcommands