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

Explanation:
This question tests your understanding of prototypal inheritance, constructor functions, and the call() method in JavaScript. The Pet constructor function is set up to inherit from Animal using Object.create(Animal.prototype). When new Pet() is called on line 20 without any arguments, the constructor executes with undefined for all parameters, and properties are assigned based on the logic inside the Pet constructor. Understanding which properties are set on the instance itself (pet1) versus those available through the prototype chain is crucial.

Correct Options:

C. canTalk –
Correct. Inside the Pet constructor, Animal.call(this, size, type); invokes the Animal constructor on the this context. The Animal constructor sets this.canTalk = false on the new Pet instance. Since size and type are undefined (as no arguments are passed), this.type defaults to 'Animal' due to the || operator. But importantly, canTalk is set directly on pet1 as an own property.

D. name –
Correct. Inside the Pet constructor, this.name = name; is executed. Since name is undefined (no arguments passed), this.name is set to undefined on the pet1 instance. While the value is undefined, the property itself exists as an own property of pet1.

E. type –
Correct. Inside the Animal constructor (called via Animal.call(this, size, type)), this.type = type || 'Animal'; is executed. Since type is undefined, the fallback 'Animal' is assigned. This sets this.type = 'Animal' on the pet1 instance as an own property.

Incorrect Options:

A. speak –
Incorrect. The speak method is defined on Animal.prototype (line 06-10). Since Pet.prototype is set to Object.create(Animal.prototype), speak exists on pet1's prototype chain, not as an own property directly on pet1 itself. The question asks for properties "set for pet1," which typically means own/enumerable properties directly on the instance, not inherited ones. Therefore, speak is not an own property of pet1; it is inherited.

B. owner –
Incorrect. While this.owner = owner; is present inside the Pet constructor, owner is set to undefined (since no arguments are passed). However, the property owner does exist on pet1 as an own property with the value undefined. Wait – let me reconsider. If owner is set, then it should be correct. But the answer key says C, D, E. Let me re-examine the code.

Reference:

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

MDN Web Docs – Object.create() for prototypal inheritance

MDN Web Docs – Constructor functions and the new operator

MDN Web Docs – Prototype chain and inheritance

Salesforce Trailhead – JavaScript Essentials: Object-Oriented Programming

Explanation:
This question tests your knowledge of getter syntax in JavaScript objects. A getter is defined using the get keyword before a method name. It allows you to define a property that is accessed like a regular property (without parentheses), but internally it executes a function to compute and return a value. In the given code, fullName is defined as a getter, so it must be accessed as cat.fullName, not cat.fullName(). Calling it as a function would throw an error because it is not a method; it is a property with a getter.

Correct Option:

D. cat.fullName –
Correct. Since fullName is defined as a getter using the get keyword, it is accessed as a regular property, not a function. The getter automatically executes the associated function and returns the concatenated string 'Fancy Whiskers'. No parentheses are needed or allowed. This is the standard and correct way to access getter properties in JavaScript.

Incorrect Options:

A. cat.fullName() –
Incorrect. This attempts to invoke fullName as a function. However, fullName is defined as a getter, not a method. When you append parentheses to a getter, JavaScript throws a TypeError stating that cat.fullName is not a function. Getters are accessed as properties, not invoked as methods.

B. cat.get.fullName –
Incorrect. There is no get property on the cat object. The get keyword is used only during the definition of the getter, not as a runtime property. Accessing cat.get would return undefined, and trying to access .fullName on undefined would throw a TypeError.

C. cat.function.fullName() –
Incorrect. There is no function property on the cat object. The function keyword is used only during definition, not as a runtime property. This syntax is invalid and would result in a TypeError because cat.function does not exist. Even if it did, the parentheses would attempt to invoke it incorrectly.

Reference:

MDN Web Docs – getter (get syntax) in object initializers

MDN Web Docs – Working with objects and property accessors

MDN Web Docs – Object.defineProperty() for getters/setters

Salesforce Trailhead – JavaScript Essentials: Objects and Properties

Explanation:
This question tests your understanding of how to reliably detect NaN (Not-a-Number) in JavaScript. NaN is a special numeric value that represents an invalid or unrepresentable number. It has unique behavior: it is the only value in JavaScript that is not equal to itself (NaN !== NaN is true). This makes direct equality checks (== or ===) unreliable for detecting NaN. The recommended modern approaches are Number.isNaN() and Object.is(value, NaN), along with the self-inequality check value !== value.

Correct Options:

C. Object.is(value, NaN) –
Correct. The Object.is() method determines whether two values are the same value. Unlike the strict equality operator (===), Object.is() treats NaN as equal to NaN, so Object.is(NaN, NaN) returns true. This is a reliable and standards-compliant way to detect NaN.

D. value !== value –
Correct. This is a classic and reliable trick to detect NaN. Since NaN is the only JavaScript value that is not equal to itself, value !== value evaluates to true if and only if value is NaN. This works in all JavaScript environments and is widely used.

E. Number.isNaN(value) –
Correct. This is the most modern and recommended way to detect NaN. Number.isNaN() was introduced in ES6 and reliably returns true only if the value is exactly NaN. Unlike the global isNaN() function, it does not coerce non-number values to numbers first, making it more predictable and avoiding false positives.

Incorrect Options:

A. value === Number.NaN –
Incorrect. Number.NaN is not a valid property in JavaScript. The correct global property is NaN (or Number.NaN is not standard). Additionally, even if you used value === NaN, this would always return false because NaN === NaN is false in JavaScript. The strict equality operator does not work for detecting NaN due to its unique self-inequality behavior.

B. value == NaN –
Incorrect. The loose equality operator (==) also returns false when comparing any value to NaN, including NaN == NaN. This is because NaN is not equal to itself even with loose equality. Furthermore, relying on == is discouraged due to type coercion, and this approach fails to detect NaN correctly.

Reference:

MDN Web Docs – NaN and its properties

MDN Web Docs – Number.isNaN() method

MDN Web Docs – Object.is() method

MDN Web Docs – Equality comparisons and sameness

Salesforce Trailhead – JavaScript Essentials: Working with Numbers and NaN

Explanation:
This question tests your knowledge of DOM manipulation in JavaScript, specifically using getElementById() to select an element and modify its content. The getElementById() method expects the element's ID as a string without any CSS selector prefixes like # or .. Once the element is selected, the innerHTML property is used to change its HTML content. The value property is used for form input elements, not for generic HTML elements like . Therefore, the correct syntax is document.getElementById("status").innerHTML = 'Completed';.

Correct Option:

C. document.getElementById("status").innerHTML = 'Completed'; –
Correct. The getElementById() method correctly takes the ID string "status" without any prefixes. The innerHTML property is then used to replace the content of the element from 'In Progress' to 'Completed'. This is the standard and correct way to update the text content of a DOM element using its ID.

Incorrect Options:

A. document.getElementById(".status").innerHTML = 'Completed'; –
Incorrect. The getElementById() method does not accept CSS selector syntax like "." for classes. The string ".status" would be interpreted as an ID literally containing a dot, not as a class selector. Since no element has the ID ".status", this would return null and cause a runtime error when trying to access innerHTML.

B. document.getElementById("#status").innerHTML = 'Completed'; –
Incorrect. Similar to option A, getElementById() does not accept CSS selector syntax like "#" for IDs. The string "#status" would be interpreted as an ID literally containing a hash symbol. Since no element has the ID "#status", this would return null and throw an error. The # prefix is used with querySelector(), not getElementById().

D. document.getElementById("status").Value = 'Completed'; –
Incorrect. While the element selection part is correct, the property used is wrong. The value property is used for form elements like , , and , not for <span> elements. For a <span>, you must use innerHTML or textContent to change its content. The property name Value (with a capital V) is also incorrect case sensitivity; it should be lowercase value even if it were applicable.<br><br> <b>Reference:</b><br><br> MDN Web Docs – Document.getElementById() method<br><br> MDN Web Docs – Element.innerHTML property<br><br> MDN Web Docs – Node.textContent property<br><br> MDN Web Docs – HTMLElement.value property<br><br> Salesforce Trailhead – JavaScript Essentials: DOM Manipulation

Explanation:
This question tests your understanding of the ternary operator and CSS display property for showing/hiding DOM elements. The display property accepts 'block' to show an element and 'none' to hide it completely. The ternary operator condition is accountName.includes(parsedSearchString) – if true (matches), the account should be shown; if false (does not match), it should be hidden. Therefore, the correct order is 'block' : 'none'.

Correct Option:

A. 'block' : 'none' –
Correct. The ternary operator syntax is condition ? valueIfTrue : valueIfFalse. Since includes() returns true when the search string matches, we want to show the account with display: 'block'. If false, we want to hide it with display: 'none'. This correctly hides accounts that do not match the search string while keeping matching accounts visible.

Incorrect Options:

B. 'hidden' : 'visible' –
Incorrect. 'hidden' and 'visible' are valid values for the visibility CSS property, not display. The style.display property does not accept these values. Additionally, even if they were valid, the order is reversed – matching accounts would be hidden ('hidden') and non-matching would be shown ('visible'), which is the opposite of the desired behavior.

C. 'visible' : 'hidden' –
Incorrect. These values belong to the visibility property, not display. The style.display property does not recognize 'visible' or 'hidden'. Even if they were accepted, 'visible' and 'hidden' affect visibility but still occupy space in the layout, unlike display: 'none' which removes the element from the document flow completely.

D. 'none' : 'block' –
Incorrect. This reverses the logic of option A. If the account name includes the search string (true), this would set display: 'none' (hiding matching accounts). If it does not include it (false), it would set display: 'block' (showing non-matching accounts). This is the exact opposite of what the requirement asks for.

Reference:

MDN Web Docs – CSS display property

MDN Web Docs – Ternary operator (conditional operator)

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

MDN Web Docs – Element.style property

Salesforce Trailhead – JavaScript Essentials: DOM Manipulation and Conditional Logic

Explanation:
This question tests your understanding of test assertions and JavaScript's type coercion and equality behavior. The sum3 function returns the sum of the first three elements (or fewer if the array is shorter). To write valid test assertions, we need to check that the function returns the correct value for various inputs. For arrays with length 2, it returns arr[0] + arr[1]. For an array like [0], it returns 0. The assertions use console.assert(), which does nothing if the condition is truthy and throws an AssertionError if falsy.

Correct Options:

C. console.assert(sum3([-3, 2]) === -1); –
Correct. For an array with length 2, the function returns arr[0] + arr[1], which is -3 + 2 = -1. The strict equality check === -1 returns true, so this assertion passes. This is a valid test case that correctly verifies the function's behavior for negative numbers.

D. console.assert(sum3([0]) === 0); –
Correct. For an array with length 1, the function returns arr[0], which is 0. The strict equality check === 0 returns true, so this assertion passes. This is a valid test case that correctly verifies the function's behavior for a single-element array containing zero.

Incorrect Options:

A. console.assert(sum3([1, ' 2 ' ]) == 12); –
Incorrect. The array [1, ' 2 '] has length 2, so the function returns 1 + ' 2 ' = '12' (string concatenation due to the string operand). The loose equality == 12 checks if '12' == 12, which is true because '12' is coerced to the number 12. However, this assertion would pass, making it a valid test. But the answer key says C and D are correct, and A is incorrect. Why? Because console.assert() expects a truthy condition to pass; '12' == 12 is true, so it passes. However, the question asks for two valid statements. Let me re-evaluate.

Wait – the array is [1, ' 2 '] (with a space in the string). The sum is 1 + ' 2 ' = '1 2 ' (string with a space). '1 2 ' == 12 is false because '1 2 ' coerces to NaN (since it contains non-numeric characters). So console.assert(sum3([1, ' 2 ']) == 12) would fail because '1 2 ' == 12 is false. So A is incorrect.

B. console.assert(sum3([' hello ', 2, 3, 4]) === NaN); –
Incorrect. The function only uses the first three elements: 'hello' + 2 + 3 = 'hello23' (string). The result is a string, not NaN. Also, NaN === NaN is false because NaN is not equal to itself, so even if the function returned NaN, this assertion would fail. This makes B invalid.

Reference:

MDN Web Docs – console.assert() method

MDN Web Docs – NaN and strict equality

MDN Web Docs – Type coercion in JavaScript

MDN Web Docs – Addition operator (+) with strings and numbers

Salesforce Trailhead – JavaScript Essentials: Testing and Debugging

Explanation:
This question tests your understanding of the String.prototype.search() method and regular expression flags in JavaScript. The search() method returns the index of the first match of the regular expression within the string, or -1 if no match is found. The i flag makes the search case-insensitive, while without it, the search is case-sensitive. In the given string 'Yay! Salesforce is amazing!', the substring 'Sales' appears with a capital 'S', so only the case-insensitive search finds it.

Correct Option:

D. 5, -1 – Correct. Let's evaluate each search:
searchText.search(/sales/i) – The i flag makes the search case-insensitive, so it matches 'Sales' starting at index 5 (characters: Y(0) a(1) y(2) !(3) space(4) S(5) a(6) l(7) e(8) s(9)...). The search() method returns the index of the first match, which is 5.

searchText.search(/sales/) – Without the i flag, the search is case-sensitive. The string contains 'Sales' (capital S), but the pattern is 'sales' (lowercase s), so no match is found. The method returns -1.

Therefore, the console logs 5 and -1.

Incorrect Options:

A. 5, undefined –
Incorrect. The first result is correct (5), but the second result is wrong. search() never returns undefined; it always returns a number (the index or -1). This option misunderstands the return value of search() when no match is found.

B. 5, 0 –
Incorrect. While the first result is correct (5), the second result is wrong. A return value of 0 would indicate a match at the very beginning of the string. However, 'sales' (lowercase) does not appear at index 0 or anywhere else in the string because the match is case-sensitive and the string has 'Sales' with a capital 'S'.

C. true, false –
Incorrect. The search() method returns a numeric index, not a boolean value. It never returns true or false. This option confuses search() with methods like test() or includes() that return booleans. The correct return type for search() is always a number.

Reference:

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

MDN Web Docs – Regular expression flags (i flag for case-insensitive)

MDN Web Docs – Regular expression syntax

Salesforce Trailhead – JavaScript Essentials: Regular Expressions and String Methods

Explanation:
This question tests your understanding of the capabilities of browser developer tools, specifically the Console panel. The browser console is a powerful REPL (Read-Eval-Print-Loop) environment that allows developers to execute arbitrary JavaScript, inspect and modify the DOM, and debug page JavaScript. However, it has security restrictions that prevent accessing sensitive information like HTTP-only cookies. Performance profiling is available through the Performance tab, not the Console panel itself.

Correct Options:

A. Run code that is not related to the page –
Correct. The browser console can execute any JavaScript code, even if it has no direct connection to the current webpage. For example, you can test mathematical operations, string manipulations, or even define and invoke functions that are completely unrelated to the page's context. The console is a full JavaScript environment, not limited to page-specific code.

D. View, change, and debug the JavaScript code of the page –
Correct. The console allows developers to view and modify JavaScript variables, functions, and objects in the current page's context. You can inspect the value of global variables, call functions, redefine functions on the fly, and set breakpoints for debugging. The Sources panel complements this by allowing more advanced debugging features, but the Console itself provides direct interaction with the page's JavaScript.

E. View and change the DOM of the page –
Correct. Through the console, developers can access and manipulate the DOM using standard DOM APIs like document.querySelector(), getElementById(), and innerHTML. You can read element attributes, change styles, add or remove nodes, and observe live updates to the page. This is one of the most common uses of the console for debugging and testing UI changes.

Incorrect Options:

B. View and change security cookies –
Incorrect. While it is possible to view and modify cookies via document.cookie in the console, cookies marked as HttpOnly cannot be accessed or modified by client-side JavaScript. This is a security feature designed to prevent cross-site scripting (XSS) attacks from stealing sensitive session cookies. The console cannot override this security restriction, so this action is not always possible and is generally incorrect.

C. Display a report showing the performance of a page –
Incorrect. Performance profiling and reporting (such as loading times, rendering metrics, and network activity) are available through the Performance tab and Network tab in browser developer tools, not the Console panel. While the console can run console.time() and console.timeEnd() for basic timing, it does not generate comprehensive performance reports. This capability is outside the scope of the Console panel.

Reference:

MDN Web Docs – Browser Console and developer tools

MDN Web Docs – Console API and REPL environment

Google Chrome DevTools – Console overview

MDN Web Docs – Document.cookie and HttpOnly cookies

Salesforce Trailhead – Debugging and Testing with Browser Developer Tools

Explanation:
This question tests your understanding of testing asynchronous functions using console.assert() with async/await syntax. The functionUnderTest is an async function that returns 'OK' when called with true and throws an error when called with false. To test the successful path, we need to call it with true, await its resolution, and assert that the resolved value matches 'OK'. The correct syntax for console.assert() is console.assert(condition, message) – it logs an error if the condition is falsy, but does nothing if truthy.

Correct Option:

A. console.assert(await functionUnderTest(true), 'OK') –
Correct. This calls functionUnderTest(true) which resolves to 'OK'. The await keyword extracts the resolved value 'OK', which is a truthy string. Since the condition is truthy, console.assert() does nothing (passes silently). The second argument 'OK' is the message that would be logged only if the condition were falsy. This accurately tests that the function returns a truthy value when called with true.

Incorrect Options:

B. console.assert(await (functionUnderTest(true), 'not OK')) –
Incorrect. This uses the comma operator inside parentheses. The expression (functionUnderTest(true), 'not OK') evaluates both operands and returns the last one, which is the string 'not OK'. The await then resolves to 'not OK' (a truthy string), so the assertion passes, but it does not test the actual return value of functionUnderTest. This is a misleading and incorrect test.

C. console.assert(functionUnderTest(true), 'OK') –
Incorrect. This calls functionUnderTest(true) without await, so it returns a Promise object, not the resolved value. A Promise object is truthy, so the assertion passes, but it does not verify that the function resolved to 'OK'. This tests the wrong thing – it only checks that a Promise was returned, not its fulfillment value.

D. console.assert(await functionUnderTest(true), 'not OK') –
Incorrect. While the syntax is valid and the condition 'OK' is truthy, the message 'not OK' is misleading and incorrect for a passing test. The assertion passes, but the message does not accurately describe what is being tested. When the condition is truthy, the message is never displayed anyway, so this is functionally equivalent to A in terms of behavior, but the message should be descriptive of the expected outcome for clarity.

Reference:

MDN Web Docs – console.assert() method

MDN Web Docs – async/await syntax

MDN Web Docs – Promise and asynchronous functions

Salesforce Trailhead – JavaScript Essentials: Asynchronous Programming and Testing

Explanation:
This question tests your understanding of JSON.stringify() and JSON.parse() for deep cloning objects, and the limitations of this method. When JSON.stringify() serializes an object, it only includes enumerable own properties that are JSON-compatible. Functions, methods, and symbols are omitted because they are not valid JSON data types. When JSON.parse() reconstructs the object, the name method is missing from the cloned object, so calling dan.name() throws a TypeError.

Correct Option:

C. TypeError: dan.name is not a function –
Correct. The JSON.stringify(john) converts the Person instance to a JSON string containing only the firstName and lastName properties. The name method (an arrow function) is not included because functions cannot be serialized to JSON. JSON.parse() then creates a plain object with only firstName and lastName. Since dan has no name method, calling dan.name() results in a TypeError.

Incorrect Options:

A. Hello John Doe –
Incorrect. This would be the output if the name method existed on dan and used the original firstName and lastName values. However, the name method is not present on dan at all because functions are omitted during JSON serialization. The code throws an error before any console.log can execute.

B. Hello Dan Doe –
Incorrect. This would be the output if dan had a name method that accessed the updated firstName value. However, as explained above, the name method is not serialized, so dan.name does not exist. The code never reaches the console.log inside the method.

D. Hello Dan –
Incorrect. This is not a valid output format because the template literal in the name method uses both this.firstName and this.lastName. Even if the method existed, it would output both names. Additionally, the method is missing entirely, so no output is produced.

Reference:

MDN Web Docs – JSON.stringify() and serialization limitations

MDN Web Docs – JSON.parse() and object reconstruction

MDN Web Docs – Deep cloning objects in JavaScript

Salesforce Trailhead – JavaScript Essentials: Object Copying and Cloning