Free CRT-600 Practice Test Questions and Answers (2026)

In JavaScript ES6 modules, which are fundamental to Lightning Web Components (LWC), named exports are used to export multiple values from a single module. Each function, class, or variable to be exported is preceded by the export keyword or listed within an export statement's curly braces. This allows a consuming module to import specific functions by their names, promoting code reusability and organization. A module can have multiple named exports but only one default export.

A. all: all is not a valid JavaScript export keyword. The syntax import as name is used for importing, not exporting.

C. multi: multi is not a recognized keyword or type of export in the JavaScript module specification.

D. default: A module can have only one default export. While an object containing multiple functions could be default-exported, the standard mechanism for exporting multiple distinct functions is via named exports.

1. Salesforce Lightning Web Components Developer Guide:

Section: Share JavaScript Code

Content: The guide demonstrates creating a utils.js module that exports multiple functions using named exports. For example: export const getToday = () => { ... }; export const getNextWeek = () => { ... };. This directly illustrates the use of named exports for sharing multiple functions.

2. MDN Web Docs (Mozilla):

Document: export statement

Section: "Named exports"

Content: "Named exports are useful to export several values. During the import

it is mandatory to use the same name of the corresponding object." The documentation provides the syntax export { name1

name2

...

nameN };

which is the standard for exporting multiple items from a module.

3. Exploring JS by Dr. Axel Rauschmayer (University-level resource):

Chapter: Modules

Section: 17.3.1 "Named exports (several per module)"

Content: "A module can export multiple things by prefixing their declarations with the keyword export. These exports are distinguished by their names and are called named exports." This academic text clearly defines the purpose and terminology of named exports for exporting multiple values.

The window.localStorage API stores data as key-value pairs, where both the key and the value must be strings. To correctly persist a JavaScript object, it must first be serialized into a string format. The JSON.stringify() method accomplishes this by converting the object into a JSON string. The setItem(key, value) method is then used to store this string in local storage under the specified key. This ensures the object's data and structure are preserved and can be retrieved and parsed back into an object later using JSON.parse().

B: The connectObject method is not a valid function within the Web Storage API for localStorage.

C: The setItem method requires two string arguments (a key and a value); this code provides only one argument, which is an object.

D: The persist method does not exist on the window.localStorage object; it is not part of the standard Web Storage API.

---

1. Mozilla Developer Network (MDN) Web Docs: The Storage.setItem() method's documentation explicitly states that the value is converted to a UTF-16 string before being stored. It provides a direct example of using JSON.stringify() to store an object.

Source: MDN Web Docs

Storage.setItem(). Retrieved from https://developer.mozilla.org/en-US/docs/Web/API/Storage/setItem#settingavalue (See "Example" section).

2. W3C Recommendation - Web Storage (Second Edition): The official specification for the Web Storage API defines the setItem method within the Storage interface. It specifies the method signature as void setItem(DOMString key

DOMString value)

confirming that both arguments must be strings.

Source: W3C

"Web Storage (Second Edition)"

12 November 2020. Section 4.3

"The Storage interface". Retrieved from https://www.w3.org/TR/webstorage/#dom-storage-setitem.

The console.assert() method is used to verify that a given expression is true. The entire expression to be evaluated must be passed as the first argument. The correct syntax for testing a function's return value is console.assert(functionCall() == expectedValue).

Options A and C correctly place the entire comparison expression inside the console.assert() call. Although the sum3 function is called with non-array arguments (e.g., sum3(-3, 2) instead of sum3([-3, 2])), causing it to return 0 and the assertions to fail, the statements themselves are structurally valid as tests. A failing assertion is a valid and useful test result.

B. console.assert(sum3(0)) == 0);

This statement incorrectly places the comparison == 0 outside the console.assert() call, comparing its return value (undefined) to 0 instead of testing the function's result.

D. console.assert(sum3(‘hello’, 2, 3, 4)) === NaN);

Similar to option B, the comparison === NaN is outside the console.assert() call. This structure does not correctly test the return value of the sum3 function.

---

1. MDN Web Docs

console.assert():

Reference: The syntax is console.assert(assertion

...data). The assertion is any boolean expression. If the assertion is false or falsy

a message is written to the console.

Location: MDN Web Docs

console.assert() page

"Syntax" and "Parameters" sections. This source confirms that the entire logical condition must be the first parameter.

2. WHATWG

Console Standard:

Reference: The specification for assert(condition

...data) states: "If condition is true

then return." This implies the entire condition to be evaluated for its truthiness must be the first argument.

Location: WHATWG Console Standard

Section 3.3 assert()

steps 1-3.

3. MDN Web Docs

Functions:

Reference: "If a function is called with more arguments than there are named parameters

the extra arguments are ignored by the named parameters." For sum3(arg1

arg2)

the parameter arr will only receive arg1.

Location: MDN Web Docs

Functions

"Parameters". This supports the analysis of how the function behaves with the provided inputs in options A and C.

The goal is to override the load method inherited from GameConsole.prototype for instances of Console16bit. This is achieved by defining a new load method directly on the Console16bit.prototype object. Option B, Console16bit.prototype.load = function(gamename) {, uses the correct syntax to assign a new function to the load property of the child's prototype. When console16bit.load() is called, the JavaScript engine finds this new function on Console16bit.prototype first in the prototype chain and executes it, producing the desired specialized output.

A. Console16bit.prototype.load(gamename) = function() { is invalid syntax. It attempts to assign a function to the result of a method call, which is not a valid assignment target.

C. Console16bit = Object.create(GameConsole.prototype).load = function (gamename) { is incorrect because it reassigns the Console16bit constructor itself, rather than modifying its prototype.

D. Console16bit.prototype.load(gamename) { is syntactically incorrect. This shorthand method syntax is only valid within class definitions or object literals, not for direct prototype assignment.

1. Mozilla Developer Network (MDN) Web Docs: The official documentation for JavaScript explains how setting a property on a more specific object in the prototype chain "shadows" the property from the less specific object. "When you set a property to an object

the property is created on the object itself... If a property with the same name exists on the prototype chain

this is called shadowing."

Source: MDN Web Docs

Object prototypes

"Shadowing properties" section. developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritanceandtheprototypechain#shadowingproperties

2. Mozilla Developer Network (MDN) Web Docs: The documentation on Object.create() explains its role in setting up prototypal inheritance

as used on line 11 of the provided code

which is the foundation for the method override.

Source: MDN Web Docs

Object.create()

"Using Object.create() for prototypal inheritance" section. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/GlobalObjects/Object/create#usingobject.createforprototypalinheritance

3. University of Washington

Paul G. Allen School of Computer Science & Engineering Courseware: University course materials on JavaScript detail the mechanism of overriding methods by re-defining them on the "child" constructor's prototype.

Source: CSE 154: Web Programming

Lecture 13: JS Objects and Prototypes

Slide 34 ("Overriding Methods"). courses.cs.washington.edu/courses/cse154/18au/lectures/13/lecture13-js-objects-prototypes.pdf

When the JavaScript execution is paused by the debugger; statement, the browser's developer tools provide access to the current state of the application.

1. The line let carSpeed = document.getElementById('CarSpeed'); has already executed. Therefore, the carSpeed variable exists in the current scope and holds a reference to a DOM element. The developer tools allow for deep inspection of this object, including its properties like style, attributes, and any attached event listeners.

2. The window.localStorage property is part of the global window object. Global objects and their properties are always accessible from the console at any point during execution, including when paused at a breakpoint.

A. The fourWheels variable is declared on the line after the debugger; statement. Since execution is paused before this line runs, the variable has not yet been declared or initialized.

B. JavaScript does not have a built-in mechanism to automatically count the number of instances created from a constructor function or class. This functionality would need to be explicitly coded.

1. Mozilla Developer Network (MDN) Web Docs: In the "Debugging JavaScript - Pausing the code" guide

it is explained that when execution is paused

the "Scope" pane displays the variables currently in scope. This includes local variables that have been declared (like carSpeed) and global objects (like window

which contains localStorage). The guide also shows how to inspect the properties of these objects.

Source: MDN Web Docs

"Debugging JavaScript

" Section: "Pausing the code." (developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Debugging#pausingthecode)

2. Chrome for Developers Documentation: The official documentation for Chrome DevTools states

"When your code is paused

the Scope pane shows you what local

closure

and global variables are currently defined

along with the value of each." This confirms that the carSpeed (local) and window.localStorage (on the global window object) would be available for inspection. The documentation also details how to inspect DOM node properties.

Source: Chrome for Developers

"JavaScript debugging reference

" Section: "View and edit local

closure

and global properties." (developer.chrome.com/docs/devtools/javascript/reference#scope)

3. W3C WebDriver Specification (Working Draft): While not a direct tutorial

the specification for browser automation tools defines the runtime environment. It implicitly confirms that the state of the global object (like window) and the current execution context's variable environment are fundamental parts of the script state accessible during a debug pause.

Source: W3C WebDriver

Section 11.1 "Scripting Contexts." (www.w3.org/TR/webdriver/#scripting-contexts)

In JavaScript, objects are treated as reference types. The statement const objB = objA; does not create a new, independent object. Instead, it creates a new reference (objB) that points to the exact same object in memory as objA. When objB is passed to the changeValue function, the function modifies the value property of that single, shared object. Consequently, when objA.value is accessed, it reflects the updated value of 5.

A. 10: This would be the result if objects were passed by value, meaning a distinct copy of objA was created for objB, which is not the case.

B. NaN: This result (Not a Number) would occur from an invalid mathematical operation, but dividing 10 by 2 is a valid calculation.

D. Undefined: This would be the result if the value property did not exist on the object, but it was explicitly initialized with the value 10.

---

1. MDN Web Docs

JavaScript Guide: In the "Working with Objects" section

it is stated: "If an object is assigned to a variable

the variable in fact holds a reference (or a "pointer") to the object. If you then assign this variable to another variable

the new variable also holds a reference to the same object." This directly supports the explanation that objA and objB reference the same object.

Source: Mozilla

MDN Web Docs

"JavaScript Guide > Working with Objects > Objects as references".

2. Eloquent JavaScript

3rd Edition: Chapter 4

"Data Structures: Objects and Arrays"

in the section on "Mutability"

explains: "The bindings object1 and object2 grasp the same object... If you change object1

you are also changing object2." This principle is identical to the behavior of objA and objB in the question.

Source: Haverbeke

M. (2018). Eloquent JavaScript (3rd ed.). No Starch Press. Chapter 4

"Mutability".

3. University of Washington

CSE 154: Web Programming: Course materials on JavaScript objects explain that when you assign one object variable to another

you are copying the reference (the "arrow")

not the object itself. Modifying the object through one variable affects the other.

Source: University of Washington

Paul G. Allen School of Computer Science & Engineering

CSE 154: Web Programming

Lecture 10: "JS Objects"

Slide on "Objects as Parameters: Reference Mystery".

The core of this question lies in the behavior of JSON.stringify(). This method converts a JavaScript object to a JSON string, but it only serializes data properties. According to the ECMAScript specification, properties whose values are functions, undefined, or Symbols are omitted during the serialization of an object. In the provided code, the name property of the john object is a function. Therefore, it is excluded from the JSON string created by JSON.stringify(john). When this string is parsed back into an object with JSON.parse(), the resulting dan object has the firstName and lastName properties but lacks the name method. The subsequent call to dan.name() attempts to invoke an undefined property, which results in a TypeError.

A. Hello Dan Doe: This is incorrect because the name method is not transferred to the dan object during the JSON serialization/deserialization process.

B. Hello John Doe: This is incorrect for the same reason as option A. The dan object does not inherit or copy the name method.

D. TypeError: Assignment to constant variable.: This is incorrect. The const declaration prevents the variable dan from being reassigned, but it does not make the object it references immutable. Modifying a property of the object (dan.firstName = 'Dan') is a valid operation.

1. Mozilla Developer Network (MDN) Web Docs: In the documentation for JSON.stringify()

under the "Description" section

it states: "If undefined

a Function

or a Symbol is encountered during conversion it is either omitted (when it is found in an object) or censored to null (when it is found in an array)." This directly confirms that the name function will be omitted. (Source: MDN Web Docs

JSON.stringify())

2. ECMAScript® 2022 Language Specification (ECMA-262

13th Edition): The official standard for JavaScript defines the serialization process. In section 25.5.2.1 SerializeJSONObject ( state

value )

step 4.c describes iterating through an object's properties. Sub-step ii specifies that if the property's value is undefined

a Symbol

or a Function

the property is skipped and not included in the output string. This formalizes the behavior observed in the question. (Source: ECMA International

ECMA-262 Standard

Section 25.5.2.1)

The question requires setting up an event and a callback to handle the server start-up process, which is a core pattern in Node.js's asynchronous, event-driven architecture. The server.on('eventName', callback) syntax is the standard method for registering an event listener. Option B correctly uses this pattern by attaching a listener to the server object for a 'connect' event. When this event is emitted by the library (signifying the server is ready), the provided callback function (port) => { console.log(...) } is executed.

A. Server.start(); is a synchronous, procedural call, not the event-driven pattern described. It also uses incorrect capitalization for the server variable.

C. server() invokes the imported module as a function. While some frameworks use this to create an app instance, it does not register an event listener.

D. serve(( port) => ( is syntactically incorrect, uses the wrong variable name (serve instead of server), and is an incomplete statement.

E. console.log( ‘Listening on ’, port); is only a logging statement. It would be placed inside a callback but does not set up the event listener itself.

1. Node.js Official Documentation

EventEmitter Class: The fundamental pattern is based on the EventEmitter class. The emitter.on(eventName

listener) method adds the listener function to the end of the listeners array for the event named eventName.

Source: Node.js v18.17.1 Documentation

events module.

Section: Class: EventEmitter

emitter.on(eventName

listener).

2. Node.js Official Documentation

Net Module: The built-in net.Server class

which is the basis for many server libraries

is an EventEmitter and emits events like connection and listening. This demonstrates the real-world application of the pattern in the question.

Source: Node.js v18.17.1 Documentation

net module.

Section: Class: net.Server

Event: 'listening'. The documentation states

"Emitted when the server has been bound after calling server.listen()."

3. MIT OpenCourseWare

6.170 Software Studio

Lecture 19: Node.js: University courseware explains that Node.js is built around an asynchronous event-driven architecture. Callbacks are registered for events

and the event loop invokes them when the corresponding event occurs. The object.on('event'

callback) pattern is central to this model.

Source: MIT OpenCourseWare

6.170 Software Studio

Spring 2013.

Reference: Lecture 19 Notes

Section on "Events".

The Object.freeze() method is used to make an existing object immutable. When an object is frozen, its properties cannot be altered in any way. This means new properties cannot be added, existing properties cannot be removed, and the values of existing properties cannot be changed. The method also prevents the modification of property descriptors (writable, configurable, enumerable). This directly fulfills the requirement to prevent properties from being added or modified.

A. Object.const() is incorrect because const is a keyword for variable declaration, not a method on the Object constructor. A const variable cannot be reassigned, but if it holds an object, the object's properties remain mutable.

B. Object.eval() is incorrect as eval() is a global function, not an Object method. It evaluates JavaScript code represented as a string and is unrelated to object immutability.

C. Object.lock() is incorrect because it is not a standard, built-in method in the JavaScript Object API.

---

1. Mozilla Developer Network (MDN) Web Docs

Object.freeze():

Section: Description

Content: "The Object.freeze() static method freezes an object. Freezing an object prevents extensions and makes existing properties non-writable and non-configurable. A frozen object can no longer be changed... The method returns the object that was passed in."

Source: MDN Web Docs: Object.freeze()

2. Salesforce Developers

Lightning Web Components Dev Guide:

Section: Reactivity > Non-Reactive Properties

Content: "To create private properties that are non-reactive

use symbols or other conventions. To prevent an object from being mutated

use Object.freeze()." This officially sanctions Object.freeze() for creating immutable objects in a Salesforce context.

Source: Salesforce Lightning Web Components Developer Guide

3. Mozilla Developer Network (MDN) Web Docs

const:

Section: Description

Content: "The const declaration creates a read-only reference to a value... It does not mean the value it holds is immutable—just that the variable identifier cannot be reassigned. For instance

in the case where the content is an object

this means the object's contents (e.g.

its properties) can be altered."

Source: MDN Web Docs: const

The code on line 05 uses a conditional (ternary) operator to set the display style property of an HTML element. The operator's structure is condition ? valueiftrue : valueiffalse.

The condition accountName.includes(parsedSearchString) evaluates to true if the account should be visible. Therefore, the valueiftrue must be a valid CSS display value that makes the element visible, such as 'block'. If the condition is false, the account should be hidden, so the valueiffalse must be 'none'.

The expression 'Block' : 'none' provides these values. CSS property values like block are case-insensitive, so 'Block' is treated as 'block'.

A. ' name ' : ' block ': This uses an invalid CSS value ('name') for the display property and reverses the intended logic.

C. ' visible ' : ' hidden ': These are valid values for the CSS visibility property, not the display property being set in the code.

D. ' hidden ' : ' visible ': These are also values for the visibility property and are therefore incorrect for setting the display property.

---

1. Mozilla Developer Network (MDN) Web Docs

HTMLElement.style: This document explains that the style property is used to get and set the inline style of an element. Individual properties like display are accessed directly (e.g.

element.style.display). This confirms the mechanism used in the code.

Source: Mozilla

"HTMLElement.style"

Accessed [Current Date]

https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/style

2. Mozilla Developer Network (MDN) Web Docs

display (CSS Property): This official documentation lists the valid values for the CSS display property. It specifies 'block' as a value that makes an element a block-level element

and 'none' as the value that turns off the display of an element

removing it from the document's layout entirely.

Source: Mozilla

"display"

CSS: Cascading Style Sheets

Accessed [Current Date]

https://developer.mozilla.org/en-US/docs/Web/CSS/display (See "Values" section for block and none).

3. Mozilla Developer Network (MDN) Web Docs

Conditional (ternary) operator: This resource details the syntax and usage of the ternary operator in JavaScript as condition ? exprIfTrue : exprIfFalse. This confirms the structure of the code on line 05 and how the chosen values will be applied based on the condition's result.

Source: Mozilla

"Conditional (ternary) operator"

JavaScript Guide

Accessed [Current Date]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/ConditionalOperator

The value NaN (Not-a-Number) is a special numeric value that results from an operation that cannot produce a meaningful number.

In option B, parseInt('two') attempts to parse a string that does not begin with a numeral. The function cannot convert 'two' into an integer and therefore correctly returns NaN.

In option C, the division operator (/) triggers numeric type coercion on the string 'five'. Since 'five' cannot be converted into a valid number, it is coerced to NaN. Any arithmetic operation involving NaN as an operand results in NaN.

A. Number('5') successfully converts the string to the number 5. The expression 10 / 5 evaluates to 2, which is a valid number.

D. In JavaScript, division of a non-zero number by 0 does not result in NaN. Instead, it evaluates to Infinity.

1. ECMAScript® 2023 Language Specification (ECMA-262

14th edition):

For parseInt (Option B): Section 19.2.5

parseInt ( string

radix )

describes the parsing process. If the input string does not contain any mathematical integer value

the result is NaN.

For Division and Type Coercion (Option C): Section 13.7

Multiplicative Operators

specifies that for the division A / B

both operands are first converted to numbers using the ToNumeric abstract operation. The string 'five' converts to NaN

and as per Table 22

Number / NaN results in NaN.

For Division by Zero (Option D): Section 6.1.6.1.5

Number::divide ( x

y )

states that if x is finite and non-zero and y is +0

the result is +Infinity.

2. MDN Web Docs (Official Mozilla Documentation for JavaScript):

parseInt(): "If the first character cannot be converted to a number

parseInt() returns NaN." (Source: MDN Web Docs

parseInt()

"Return value" section).

NaN: "NaN is a property of the global object. It is a value representing Not-A-Number. ... It is the returned value when Math functions fail (e.g.

Math.sqrt(-1)) or when a function trying to parse a number fails (e.g.

parseInt('blabla'))." (Source: MDN Web Docs

NaN

"Description" section).

Arithmetic Operators: "If one of the operands is a string that cannot be converted to a number

the result is NaN." (Source: MDN Web Docs

"Arithmetic operators"

"Division (/)" section).

The console.assert() method is the correct choice as it is specifically designed to log an error message to the console if and only if its first argument (the assertion) evaluates to false. This directly fulfills the second requirement. Furthermore, the console object is a standard, globally available feature in both browser JavaScript environments and Node.js, satisfying the third requirement for cross-platform compatibility.

While the first requirement ("Does require an import") appears to be a flawed premise in the question—as no single option satisfies all three conditions—console.assert() is the only choice that correctly implements the core functional logic described in requirements two and three.

A. assert (number % 2 === 0); is incorrect because the assert module is specific to Node.js and is not natively available in browsers, thus failing the cross-platform requirement.

B. console.error(number % 2 === 0); is incorrect because it does not log an error conditionally. It logs the boolean result (true or false) of the expression on every iteration of the loop.

C. console.debug(number % 2 === 0); is incorrect because it logs a debug-level message, not an error, and it does so on every iteration rather than conditionally when the statement is false.

1. Node.js Official Documentation

Console API: The documentation confirms that console.assert(value[

...message]) is part of the global console object and functions as an assertion. It states

"If value is falsy

it writes a message to the console." This confirms its behavior and availability in Node.js without an import. (See: Node.js v18.17.1 Documentation

Console API

console.assert()).

2. MDN Web Docs

Console API: The MDN documentation for the console.assert() method specifies its cross-platform availability and function: "Logs a message and stack trace to the console if the first argument is false." This confirms its behavior and availability in standard web browsers. (See: MDN Web Docs

Web APIs

console.assert()).

The goal is to set the deliveryDate object to 9 days from the current date. The Date.prototype.setDate() method is designed for this. It sets the day of the month for a Date object. Crucially, if the provided day value exceeds the number of days in the current month, the method automatically adjusts the month and year accordingly. The expression (new Date()).getDate() + 9 retrieves the current day of the month (e.g., 15) and adds 9 to it. Passing this result to deliveryDate.setDate() correctly calculates and sets the date to 9 days in the future, handling month and year rollovers.

B. Date.current() is not a standard JavaScript function. The correct static method is Date.now(), which returns milliseconds, an invalid value for the setDate() method.

C. A JavaScript Date object does not have a public property named .date for assignment. Also, new Date(+9) creates a date 9 milliseconds after the 1970 epoch.

D. This option has two errors: it attempts to assign to the non-existent .date property and calls the non-existent Date.current() function.

1. Mozilla Developer Network (MDN) Web Docs

Date.prototype.setDate(): "The setDate() method of a Date instance changes the day of the month for this date according to local time... If the dayValue is outside of the range of date values for the month

setDate() will update the Date object accordingly." This confirms the rollover behavior essential for the correct answer.

Source: Mozilla

Date.prototype.setDate()

Accessed on [Current Date]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/GlobalObjects/Date/setDate

2. Mozilla Developer Network (MDN) Web Docs

Date.prototype.getDate(): "The getDate() method of a Date instance returns the day of the month for this date according to local time." This confirms the method used to retrieve the current day number.

Source: Mozilla

Date.prototype.getDate()

Accessed on [Current Date]

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/GlobalObjects/Date/getDate

3. ECMAScript® 2023 Language Specification (ECMA-262

14th edition): The behavior of setDate is formally defined. The specification details the internal SetDate abstract operation

which correctly calculates the final date when the day argument causes the month or year to change.

Source: ECMA International

ECMAScript Language Specification

14th Edition

June 2023

Section 21.4.4.25 Date.prototype.setDate ( date ).

To create a secure web server in Node.js without third-party libraries, the built-in https module must be used. This module provides the functionality for creating an HTTPS server, which is essentially an HTTP server operating over a TLS/SSL encrypted connection. The https.createServer() method is the standard way to instantiate such a server, requiring SSL certificate and key files. This directly fulfills the requirement for a "secure web server" using the native Node.js API.

B. const server =require(‘secure-server’);

secure-server is not a core Node.js module. Requiring it would necessitate installing a third-party library, which is explicitly forbidden by the question.

C. const tls = require(‘tls’);

The tls module provides the underlying security protocol (TLS/SSL) but is not the high-level API for creating a secure web (HTTP) server.

D. const http =require(‘http’);

The http module is used to create an unencrypted, insecure web server. This directly contradicts the requirement for a "secure" server.

1. Node.js v18.18.0 Documentation

HTTPS Module: "The https module provides an implementation of the TLS/SSL protocol for Node.js. The API of https is very similar to that of http." The documentation further provides a direct example: const https = require('node:https'); ... https.createServer(options

(req

res) => { ... });

Source: Official Node.js Documentation

https module API. Section: https.createServer(options[

requestListener]).

2. Node.js v18.18.0 Documentation

HTTP Module: "To use the HTTP server and client

one must require('node:http')." This module is explicitly for the unencrypted HTTP protocol.

Source: Official Node.js Documentation

http module API.

3. Node.js v18.18.0 Documentation

TLS (Transport Layer Security) Module: "The node:tls module provides an implementation of the Transport Layer Security (TLS) and Secure Socket Layer (SSL) protocols... It provides a stream-based API for secure communication." This shows it is a lower-level protocol implementation

not the specific API for an HTTPS server.

Source: Official Node.js Documentation

tls module API.

The question requires importing all functions from a module into a single object and then calling them. This is achieved using the ES6 module "namespace import" syntax: import as from ''. This statement imports all named exports from the specified module and assigns them as properties to a newly created object, here named lib. The functions foo and bar can then be correctly called as methods on this lib object.

Note: The provided option 'A' contains a common typographical error where ad is used instead of the correct keyword as. Despite this typo, it is the only option that correctly represents the required namespace import pattern and subsequent function calls.

B: This attempts a "named import," which only imports the specified functions (foo, bar), not every function as required. The syntax is also incorrect, using parentheses () instead of curly braces {}.

C: The syntax import all from ... is not a valid ES6 module syntax for a namespace import. Additionally, it attempts to call functions on universalContainersLib, which was not the alias used in the import.

D: The syntax import from ... is incomplete and invalid. A namespace import requires an alias for the module object, specified with as .

1. Salesforce Lightning Web Components Developer Guide: The documentation explicitly shows the use of standard ES6 modules

including namespace imports. Under "Import from Another Component's JavaScript File

" the guide details the import syntax. The pattern import as ... is consistent with standard JavaScript. (See section: JavaScript Modules).

2. MDN Web Docs - import statement: This is the de-facto standard reference for JavaScript syntax. It defines the namespace import syntax as: import as name from "module-name";. This creates a module namespace object (name) containing all the exports from "module-name". (See section: Syntax > Import a module's contents).

The JavaScript engine will throw a ReferenceError. The function is defined as myfunction (all lowercase), but the invocation is myFunction() (with a capital 'F'). JavaScript is a case-sensitive language, meaning myfunction and myFunction are treated as two distinct identifiers. Since no function named myFunction has been defined in the scope, the attempt to call it results in a ReferenceError. The code inside the myfunction block, including the "use strict"; directive, is never executed.

1. Mozilla Developer Network (MDN) Web Docs: In the "JavaScript Guide > Grammar and types" section

it is explicitly stated: "JavaScript is a case-sensitive language. This means that language keywords

variables

function names

and other identifiers must always be typed with a consistent capitalization of letters." (See "Case sensitivity" subsection).

2. ECMA-262

13th Edition (ECMAScript® 2022 Language Specification): Section 6.1.2

"The Undefined Type

" and Section 7.2.2

"IsUnresolvableReference ( V )

" detail the process of reference resolution. An identifier that cannot be resolved in the current lexical environment

such as the call to the non-existent myFunction

results in an unresolvable reference

which leads to a ReferenceError being thrown.

3. Flanagan

D. (2020). JavaScript: The Definitive Guide (7th ed.). O'Reilly Media. Chapter 2

"Lexical Structure

" Section "Case-Sensitivity

" states

"JavaScript is a case-sensitive language. This means that keywords

variables

function names

and other identifiers must always be typed with a consistent capitalization of letters." (p. 16).

4. Haverbeke

M. (2018). Eloquent JavaScript (3rd ed.). No Starch Press. Chapter 2

"Program Structure

" under the section "Bindings

" explains that bindings (variables and functions) have names

and these names are case-sensitive. The text notes

"The names of bindings

also called identifiers

can be any word... Casing matters—catch and Catch are different names." (p. 23).

Both slice(start, end) and substring(start, end) methods extract a portion of a string. The start parameter specifies the zero-based index at which to begin extraction, and the end parameter specifies the index before which to end extraction. For the string 'Salesforce', the substring 'Sales' begins at index 0 and ends at index 4. Therefore, specifying a start of 0 and an end of 5 will extract characters from index 0 up to, but not including, index 5, resulting in 'Sales'.

1. ECMA International. (2023). ECMAScript® 2023 Language Specification (14th ed.

ECMA-262). Section 22.1.3.26

String.prototype.slice(start

end)

and Section 22.1.3.30

String.prototype.substring(start

end). The specification details that both methods extract characters from the start index up to the end index

where the character at the end index is not included.

2. Massachusetts Institute of Technology. (2013). 6.170 Software Studio

Lecture 2: JavaScript. MIT OpenCourseWare. The lecture notes cover core JavaScript features

including string manipulation methods like slice and substring

explaining their usage for extracting parts of a string based on indices. (ocw.mit.edu)

3. Haverbeke

M. (2018). Eloquent JavaScript (3rd ed.). No Starch Press. Chapter 4

"Data Structures: Objects and Arrays

" section on "Strings and their properties." This text

often used in university curricula

explains that slice and substring are similar in taking start and end indices to create a new string.

The debugger statement programmatically creates a breakpoint in the code. To "step into each function execution," the developer must pause the code before the first function is called. Placing the debugger statement on line 03 accomplishes this. When the code pauses, the developer can use the debugging tools' "Step into" command to enter the findSubTotal function. Upon returning from it, execution will pause at the next line, allowing the developer to then step into addTax, and subsequently addTip. This is the only option that facilitates stepping into all three functions sequentially from a single breakpoint.

A. Using the debugger command on line 05 is too late. It only allows stepping into the addTip function, as findSubTotal and addTax have already executed.

C. The console.trace() method outputs the function call stack to the console but does not pause execution, which is required for stepping into functions.

D. Wrapping a function in console.log() only prints its return value. It does not pause execution or provide a mechanism to step into the function's code.

1. Mozilla Developer Network (MDN) Web Docs: The debugger statement is an official part of the ECMAScript specification. The MDN documentation states

"The debugger statement invokes any available debugging functionality... If no debugging functionality is available

this statement has no effect. The purpose of the debugger statement is to stop the execution of code at a specific point." This supports using debugger to create a breakpoint from which one can step into subsequent code.

Source: MDN Web Docs

debugger statement. Section: "Syntax".

2. Salesforce Lightning Web Components Developer Guide: In the context of JavaScript development for Salesforce (relevant to CRT-600)

the official documentation recommends using browser developer tools and the debugger statement for debugging. It explains how breakpoints pause execution

allowing for inspection and stepping through code.

Source: Salesforce Developers

Lightning Web Components Dev Guide

"Debug Your Code". Section: "Debug JavaScript".

3. Google Chrome for Developers Documentation: This is an authoritative source on using debugging tools. It describes the "Step into next function call" action

which is only available when execution is paused at a breakpoint

such as one created by a debugger statement.

Source: Chrome for Developers

JavaScript debugging reference. Section: "Step through code".

In JavaScript, arrays are reference types. A direct assignment (let arr2 = arr1;) creates a new variable arr2 that points to the same memory location as arr1, not a new array. To create a true copy, a method that returns a new array instance must be used.

The slice() method extracts a portion of an array and returns a new, shallow-copied array object. Similarly, Array.from() creates a new, shallow-copied Array instance from an iterable object like an array. Both methods result in arr2 being a distinct array in memory, independent of arr1.

C. Let arr2 = arr1;

This line creates a reference. The variable arr2 will point to the exact same array object as arr1, not a new one.

D. Let arr2 = arr1.sort();

The sort() method modifies the array in-place and returns a reference to that same, now-sorted, original array.

1. Mozilla Developer Network (MDN) Web Docs

Array.prototype.slice(): "The slice() method returns a shallow copy of a portion of an array into a new array object selected from start to end (end not included) where start and end represent the index of items in that array. The original array will not be modified." (Section: "Return value").

2. Mozilla Developer Network (MDN) Web Docs

Array.from(): "The Array.from() static method creates a new

shallow-copied Array instance from an iterable or array-like object." (Section: "Description").

3. Mozilla Developer Network (MDN) Web Docs

Array.prototype.sort(): "The sort() method sorts the elements of an array in place and returns the reference to the same array

now sorted. The default sort order is ascending..." (Section: "Return value").

4. Eloquent JavaScript

3rd Edition by Marijn Haverbeke (a resource used in many university curricula): "Objects and arrays

on the other hand

are stored differently... When you copy a variable that holds an object

you are copying the reference to that object

not the object itself... If you want to create a new array with the same elements

you can use the slice method with no arguments." (Chapter 4: Data Structures: Objects and Arrays

Section: "Objects and arrays are mutable").

The scenario describes a classic web development issue where a tester sees an outdated version of a webpage due to browser caching, while the developer, who often has caching disabled in their development environment, sees the live version. The most direct actions to resolve this and ensure the tester sees the updated content ("accurate results") are for the tester to bypass their local cache. Both clearing the browser cache (a one-time fix) and disabling the browser cache (a persistent fix for the testing session) will force the browser to download the latest files from the server, thus showing the intended changes.

A. The developer should inspect their browser refresh settings.

This is a diagnostic step to understand why it works for the developer, but it does not directly help the tester see the accurate results on their own machine.

C. The developer should rework the code.

This is premature. There is no evidence of a code defect, as the functionality works in the developer's environment, strongly indicating an environmental issue like caching.

1. Salesforce Lightning Web Components Developer Guide: In the "Develop Your Component" section

under "Preview Your Component

" the documentation frequently advises developers on how to see their most recent changes. A common instruction is: "To ensure that you’re seeing your most recent changes during development

empty the cache and do a hard reload of the page in your browser." This directly supports the actions of clearing or disabling the cache (Options D and B) as a standard procedure to resolve stale content issues.

2. MDN Web Docs (Mozilla Developer Network): As a foundational resource for web technologies used in Salesforce development

MDN's documentation on "HTTP Caching" explains this exact problem. In the "Stale responses" section

it details how browsers store copies of resources. The prescribed user-side solutions are to force a reload that bypasses the cache

which is achieved by clearing the cache or using developer tools to disable it. This principle is fundamental to web development and testing curricula at an academic level. (Reference: MDN Web Docs

HTTP Caching

section on "Forcing a reload").