Free Practice Questions for Salesforce JavaScript-Developer-I Exam

React and Vue are:

Mature front-end JavaScript frameworks/libraries.

Have large communities.

Are widely supported and used in production across industries.

Appropriate for building browser-based Single Page Applications.

Express and Koa are server-side frameworks , not front-end SPA frameworks.

The scenario describes building a browser SPA, so the correct seasoned options are React and Vue.

JavaScript Knowledge References (text-only)

React and Vue are client-side frameworks for SPA development.

Express and Koa are backend frameworks for Node.js.

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

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.

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

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

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

1. Getter Functions in JavaScript

In JavaScript, when an object uses the get keyword, it defines a getter method . Accessing a getter property executes the function and returns its value. Thus:

o.js

does not return the getter function; instead, it executes the function located at:

get js() { ... }

and returns the object inside the return block.

2. Behavior of String() and toLowerCase()

Inside the getter:

let city1 = String( ' St. Louis ' );

let city2 = String( ' New York ' );

String() creates a string value.

Then, the returned object is constructed as:

{

firstCity: city1.toLowerCase(),

secondCity: city2.toLowerCase(),

}

The method toLowerCase() is a standard JavaScript string method that returns a new string with all alphabetic characters converted to lowercase .

Therefore:

city2.toLowerCase()

returns:

' new york '

3. Referencing the Property

When the developer writes:

o.js.secondCity

the following happens:

The getter js runs and returns an object.

The returned object includes the property:

secondCity: ' new york '

Accessing .secondCity retrieves the lowercase string ' new york ' .

Therefore, the correct value is ' new york ' .

Why the Other Options Are Incorrect

A. undefined – incorrect because the property secondCity clearly exists in the returned object.

B. An error – incorrect because no invalid operations occur; all methods and properties are valid.

C. ' New York ' – incorrect because toLowerCase() transforms the string to lowercase.

JavaScript Knowledge References (Text-Based)

Getter methods using the get keyword return computed values when accessed.

JavaScript String values support the toLowerCase() method, which returns a lowercase version of the original string.

Accessing nested properties like o.js.secondCity triggers the getter, returning the constructed object.

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.

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.

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

str = ' Salesforce '

Index positions:

S(0) a(1) l(2) e(3) s(4) f(5) o(6) r(7) c(8) e(9)

substring(start, end)

Start index inclusive, end index exclusive.

str.substring(0, 5) → characters at indices 0–4 → " Sales "

str.substring(1, 5) → indices 1–4 → " ales "

substr(start, length)

Start index, then number of characters.

str.substr(0, 5) → 5 characters starting at index 0 → " Sales "

str.substr(1, 5) → 5 characters from index 1 → " alesf "

So the expressions that return " Sales " are A and C.

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.