Free Practice Questions for Salesforce JavaScript-Developer-I Exam

The correct answer is C .

The original option contains a typing error. It should use the existing variable name:

let numberValue = Number(strNumber);

The value of strNumber is a string:

' 12345 '

Using Number() converts the numeric string into a JavaScript number:

12345

So after execution:

typeof numberValue;

returns:

" number "

Professional review of each option:

Option

Result

Explanation

A

Incorrect

JavaScript does not have a standard global Integer() conversion function.

B

Incorrect

Strings do not have a standard .toInteger() method.

C

Correct

Number(strNumber) correctly converts ' 12345 ' into 12345.

D

Incorrect

This is not valid JavaScript casting syntax.

A commonly used alternative would also be:

let numberValue = parseInt(strNumber, 10);

But from the provided answer choices, the verified answer is C .

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.

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.

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.

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

document.querySelector( ' #row-as ' ) returns the single element with id row-as.

That element has a classList property with add, remove, etc.

Correct usage:

document.querySelector( ' #row-as ' ).classList.add( ' priority-account ' );

Why others are wrong:

A: querySelectorAll returns a NodeList, not a single element, so it does not have a classList property.

C: DOM elements do not have a classes array or push; they have classList.

D: document.getElementById( ' row-as ' ) is fine to get the element, but there is no addClass method in standard DOM; that’s a jQuery-style API, not vanilla JS.

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

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 .

Requirement:

getNextValue() should run only if handleObjectValue(x) does not throw an error.

If an error occurs, handleError(error) should run, and getNextValue() should be skipped.

Option B:

try {

handleObjectValue(x);

getNextValue();

} catch (error) {

handleError(error);

}

Behavior:

If handleObjectValue(x) succeeds (no error):

Execution continues to getNextValue();.

If handleObjectValue(x) throws:

Control jumps directly to catch, getNextValue() is skipped.

handleError(error); is called.

This matches the requirement perfectly.

Why others are incorrect:

A: } then { is invalid JavaScript syntax.

C:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

}

getNextValue();

getNextValue() is called after the try...catch regardless of whether an error occurred. Not acceptable.

D: finally always runs:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

} finally {

getNextValue();

}

getNextValue() will execute in both success and error cases.

Therefore, the correct approach is B.

Concepts: try/catch control flow, finally semantics, placing code inside vs outside try/catch blocks.

Browsers often cache JavaScript, CSS, and HTML. This means:

The developer may be running with the latest version (often with cache disabled in DevTools).

The tester may still be loading an older, cached version of the page where the background-change logic does not exist.

To ensure they are actually testing the latest deployed code:

Disabling cache (A) in the tester’s browser (usually via DevTools → Network → “Disable cache”) forces fresh loading of all resources on each refresh.

Clearing cache (C) removes older resources from the browser so the next load fetches fresh files from the server.

Options B and D do not directly help verify the tester is using the latest code:

B checks the developer’s own browser, which is not the environment showing the problem.

D suggests reworking the code before confirming whether the tester is actually loading the correct version, which is premature.

So the two actions that help produce accurate testing results are A and C.