JAVASCRIPT-DEVELOPER-I Practice Questions

To create a secure web server in Node.js without third-party libraries, the built-in https module is required. This module provides the functionality to create an HTTPS server, which is the standard for secure web communication. It is an implementation of the HTTP protocol over a TLS/SSL encrypted connection. The https.createServer() method is used to instantiate a new secure server, which requires SSL certificate details to operate. This directly fulfills the requirement of setting up a "secure web server" using Node.js core functionalities.

B. secure-server is not a built-in core module in Node.js. Using it would require installing a third-party library, which violates the problem's constraint.

C. The tls module provides the underlying Transport Layer Security protocol, but it is a lower-level API for secure streams, not a high-level web server implementation.

D. The http module creates a standard, unencrypted HTTP server. This is inherently insecure and does not meet the requirement for a "secure web server".

1. Node.js v20.12.2 Documentation, HTTPS: The official documentation explicitly states, "The https module provides an implementation of the TLS/SSL protocol for Node.js." The primary method for creating a secure server is https.createServer().

Reference: Node.js Documentation, https module, Introduction section. (https://nodejs.org/api/https.html)

2. Node.js v20.12.2 Documentation, HTTP: This documentation describes the http module for creating standard web servers, which are unencrypted by default, confirming why option D is incorrect.

Reference: Node.js Documentation, http module, http.createServer() section. (https://nodejs.org/api/http.html#httpcreateserveroptions-requestlistener)

3. Node.js v20.12.2 Documentation, TLS (Transport Layer Security): This source clarifies that the tls module provides the underlying security protocol upon which https is built, making https the correct high-level abstraction for a web server.

Reference: Node.js Documentation, tls module, Class: tls.Server section. (https://nodejs.org/api/tls.html#class-tlsserver)

4. Salesforce Trailhead, JavaScript Developer I Cert Prep: Server-Side JavaScript: This module establishes that knowledge of core Node.js modules is a key objective for the certification, including how to handle web requests.

Reference: Trailhead, "Understand Server-Side JavaScript with Node.js" unit. (https://trailhead.salesforce.com/content/learn/modules/javascriptdevelopericertificationprepserversidejavascript/understand-server-side-javascript-with-nodejs)

The code utilizes JavaScript's array destructuring assignment with a rest parameter. The expression const [a, b, ...others] = numbers; performs the following actions:

1. The first element of the numbers array, 0, is assigned to the constant a.

2. The second element, 1, is assigned to the constant b.

3. The rest parameter ...others collects all remaining elements into a new array, so others becomes [2, 3, 4, 5].

The console.log statements then output a (0), b (1), others[0] (2), and others[0] again (2). This results in the sequence 0122.

A. 0012: This is incorrect. The second variable, b, is assigned the value 1, not 0.

B. 0112: This is incorrect. The third logged value is others[0], which is 2, not 1.

D. 0123: This is incorrect. The fourth console.log statement calls others[0] again, not others[1], so it logs 2 a second time instead of 3.

1. MDN Web Docs (Mozilla): The "Destructuring assignment" documentation explains the use of the rest property in array destructuring. It states, "The rest property can be used to collect the remaining items in an array." This directly supports the analysis that others becomes [2, 3, 4, 5].

Source: MDN Web Docs, Destructuring assignment, "Array destructuring" section, "Rest property" subsection. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuringassignment#restproperty

2. Eloquent JavaScript, 3rd Edition (University-level Text): This book, often used in computer science curricula, details how destructuring works with the rest operator. It clarifies that ... "grabs all remaining elements" into a new array.

Source: Haverbeke, M. (2018). Eloquent JavaScript (3rd ed.). No Starch Press. Chapter 4, "Data Structures: Objects and Arrays," section on "Destructuring." https://eloquentjavascript.net/04data.html#h5Eca2uS8S/

3. Salesforce Lightning Web Components Developer Guide: The guide emphasizes the use of modern JavaScript (ES6 and later), which includes destructuring assignment as a core feature for writing efficient and readable Lightning Web Components.

Source: Salesforce Developers, Lightning Web Components Developer Guide, "Modern JavaScript (ES6 and Later)". https://developer.salesforce.com/docs/component-library/documentation/en/lwc/lwc.jsgeneral

The logical AND (&&) operator in JavaScript evaluates operands and returns the value of the first falsy operand it encounters, or the value of the last operand if all are truthy. This returned value is not necessarily a boolean. To guarantee a boolean result, an explicit conversion is required.

Option A, Boolean(var1 && var2), first evaluates var1 && var2 and then explicitly converts the resulting value to a boolean using the Boolean() function.

Option D, Boolean(var1) && Boolean(var2), first converts each variable to a boolean and then performs the logical AND operation on the two resulting boolean values. Both methods correctly perform the logical AND and ensure the final data type is Boolean.

Why Incorrect Options are Wrong

B. var1 && var2

This expression returns the actual value of one of the operands, not necessarily a boolean. For example, 'a' && 'b' returns 'b'.

C. var1.toBoolean() && var2toBoolean()

The .toBoolean() method does not exist on standard JavaScript data types (like String, Number, etc.), and calling it would result in a TypeError.

References

1. MDN Web Docs (Mozilla): Logical AND (&&)

Reference: In the "Description" section, it states, "The logical AND (&&) operator... returns expr1 if it can be converted to false; otherwise, it returns expr2. Thus, when used with Boolean values, && returns true if both operands are true; otherwise, it returns false." This highlights that the return value is not always a boolean when used with non-boolean operands.

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

2. MDN Web Docs (Mozilla): Boolean

Reference: The documentation for the Boolean() function (when used without new) states: "The value passed as the first parameter is converted to a boolean value, if necessary." This confirms its role in explicit type coercion, which is central to options A and D.

URL: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/GlobalObjects/Boolean

3. ECMAScript® 2023 Language Specification (ECMA-262, 14th edition):

Reference: Section 13.13, "Binary Logical Operators", defines the runtime semantics for the && operator. The algorithm shows that it returns the value of one of the expressions (lval or rval), not necessarily a boolean primitive.

Reference: Section 7.1.2, "ToBoolean ( argument )", specifies the abstract operation for converting any ECMAScript language value to a boolean value, which is the underlying mechanism used by the Boolean() function.

URL: https://tc39.es/ecma262/#sec-binary-logical-operators and https://tc39.es/ecma262/#sec-toboolean

The scenario describes replacing a real dependency (database.query) with a test double. This technique is known as Mocking. Mocks are configured with expectations about how they will be used (e.g., number of calls, arguments) and can verify these interactions.

This approach is also a form of White-box testing. White-box testing requires knowledge of the internal implementation of the code. Verifying that a specific internal method was called a certain number of times with specific arguments is a classic example of testing the code's internal logic and structure, rather than just its external output.

A. Integration: Integration testing verifies that different modules work together. The described approach does the opposite by isolating the unit from its database dependency.

B. Black box: Black-box testing evaluates functionality without knowledge of the internal implementation. This test specifically inspects internal behavior (method calls and arguments).

1. Salesforce Lightning Web Components Developer Guide: The section on Jest testing explicitly details the use of mocks to isolate components from dependencies. It states, "To test a component in isolation, mock its dependencies... Jest provides a mocking framework that you can use." This directly supports the concept of Mocking (D).

Source: Lightning Web Components Developer Guide, Module: Test Lightning Web Components, Section: Mock Dependencies.

2. Salesforce Lightning Web Components Developer Guide: The guide shows examples of verifying interactions with mocks using matchers like toHaveBeenCalled() and toHaveBeenCalledWith(). This verification of internal logic is a hallmark of White-box testing (C).

Source: Lightning Web Components Developer Guide, Module: Test Lightning Web Components, Section: Verify a Mock Was Called.

3. MIT OpenCourseWare, 6.031: Software Construction: Course materials define testing strategies. White-box testing is described as choosing test cases based on the code's internal structure, including statements and paths exercised. Verifying internal method calls fits this definition.

Source: MIT OpenCourseWare, 6.031 Software Construction, Spring 2016, Reading 16: Testing. Section: "Whitebox testing".

4. Martin Fowler, "Mocks Aren't Stubs": This foundational article, widely cited in academic and professional software engineering contexts, defines a mock as an object that verifies behavior. The question's requirement to "verify how many times the method was called and the arguments used" is the primary purpose of a mock object.

Source: Fowler, M. (2007). Mocks Aren't Stubs. martinfowler.com. Section: "Mocks".

JavaScript is a case-sensitive language. The code defines a property Job (with a capital 'J') on the Person.prototype object. However, line 10 attempts to call myFather.job() (with a lowercase 'j').

When myFather.job is accessed, the JavaScript engine first checks the myFather object itself. Finding no job property, it then searches the prototype chain. The prototype object has a property named Job, but not job. Because no property named job is found, the expression myFather.job evaluates to undefined. Attempting to invoke undefined as a function (undefined()) throws a TypeError.

B. Undefined Developer: This is incorrect because myFather.firstName is 'John', and more importantly, the code execution halts with a TypeError before any string concatenation can occur.

C. John undefined: This would be the result if myFather.job() returned the value undefined. Instead, the code throws an error when trying to execute undefined as a function.

D. John Developer: This would be the correct output only if the property on the prototype was named job (lowercase), matching the function call. Due to case sensitivity, this is not the case.

1. Mozilla Developer Network (MDN) Web Docs, TypeError: "x" is not a function: "The TypeError: "x" is not a function error occurs when there was an attempt to call a value from a function, but the value is not actually a function. ... For example, in JavaScript, case matters. Function names must be called with their correct case." This directly explains the error seen in the question.

Source: MDN Web Docs, TypeError: "x" is not a function, section "Message".

2. Mozilla Developer Network (MDN) Web Docs, Inheritance and the prototype chain: "When it comes to inheritance, JavaScript only has one construct: objects. Each object has a private property which holds a link to another object called its prototype. ... When trying to access a property of an object, the property will not only be sought on the object but on the prototype of the object, the prototype of the prototype, and so on..." This explains the property lookup mechanism.

Source: MDN Web Docs, Inheritance and the prototype chain, section "Inheriting properties".

3. ECMAScript® 2024 Language Specification (ECMA-262, 15th edition): The specification implicitly defines case sensitivity through its grammar for identifiers (e.g., IdentifierName). It does not treat identifiers with different casing as equivalent.

Source: ECMA-262, 15th Edition, June 2024, Section 12.1, "Identifiers".

In JavaScript ES6 modules, which are fundamental to Lightning Web Components, there are two types of exports: named and default. A module can have multiple named exports but only one default export. To make multiple functions from a single module (like ErrorHandler) available for other modules to import and use, named exports must be used. Each function is exported using the export keyword followed by its declaration, and imported using its specific name within curly braces {}.

A. all: export all is not a valid JavaScript syntax for exporting multiple functions from the current module. The export from 'module' syntax is for re-exporting from another module.

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

D. default: A module can only have one default export. This is typically used for the main or primary value of a module, not for exporting multiple, distinct functions.

1. Salesforce Lightning Web Components Developer Guide:

Section: Share JavaScript Code

Content: The documentation explicitly demonstrates using named export statements to share multiple utility functions from a JavaScript file. It states, "To import the functions, use the import statement with the function names in curly braces." This directly supports the use of named exports for multiple functions.

2. MDN Web Docs (Mozilla):

Page: export statement

Content: This is a canonical resource for the JavaScript language. It clearly defines and provides syntax for "Named exports" and "Default export." The documentation specifies, "Named exports are useful to export several values. During the import, one will be able to use the same name to refer to the corresponding value." This confirms that exporting "multiple functions" requires named exports.

3. ExploringJS by Dr. Axel Rauschmayer (Academic Resource):

Chapter: 17. Modules

Section: 17.3.1 Named exports (several per module)

Content: This text, often used in academic settings, explains, "You can have multiple named exports per module. A named export is created by prefixing a declaration with the keyword export." This academic source validates that the standard mechanism for exporting several items is the named export.

The code defines a function sum that uses the Array.prototype.reduce() method. The reduce() method executes a callback function on each element of an array to produce a single output value. This method can optionally accept a second argument, an initialValue, which serves as the starting value for the accumulator.

In this scenario, the reduce() method is called on an empty array [] with an initialValue of 5. According to the ECMAScript specification, if reduce() is called on an empty array and an initialValue is provided, the callback function is not executed, and the initialValue is returned directly. Therefore, the function call sum([]) returns 5.

A. Return 0: This would be the result if the provided initialValue was 0, not 5.

C. Return NaN: NaN (Not-a-Number) is not produced because no invalid mathematical operations occur; the reduction callback is never even called.

D. Return Infinity: The operation does not involve division by zero or any other calculation that would result in Infinity.

---

1. MDN Web Docs (Mozilla): In the documentation for Array.prototype.reduce(), under the section "How reduce() works", it states: "If initialValue is provided, the reducer function is called for each element in the array... If the array is empty, initialValue is returned."

Source: MDN Web Docs, Array.prototype.reduce(), "Return value" section.

2. ECMAScript® 2023 Language Specification (ECMA-262, 14th edition): The official standard for JavaScript defines the behavior of Array.prototype.reduce.

Source: Section 23.1.3.26, Array.prototype.reduce ( callbackfn [ , initialValue ] ), Step 7: "If len is 0 and initialValue is present, return initialValue." This algorithm step directly confirms that for an empty array (length is 0), the provided initial value is returned.

3. University of Washington, Paul G. Allen School of Computer Science & Engineering: Course materials for CSE 154: Web Programming explain higher-order functions.

Source: Lecture notes on "JavaScript Arrays" typically clarify that when using reduce on an empty array, providing an initial value prevents an error and results in that initial value being returned.

To dispatch a custom event with data in Lightning Web Components, the CustomEvent constructor is used with the signature new CustomEvent(eventName, options). The eventName is a string, and options is an object where the data payload is passed within a property named detail.

Option D, ‘Update’ , {Details : {recordId : ‘123abc’}}, correctly provides a string as the first argument and an object as the second. However, it uses the property name Details (uppercase 'D'). The correct property name is detail (lowercase 'd'). Assuming Details is a typo for detail, this option correctly encapsulates the recordId within the event's data payload.

A. ‘Update’ , (recordId : ‘123abc’(

This option is syntactically invalid JavaScript. The use of parentheses () instead of curly braces {} for an object literal is a syntax error.

B. ‘Update’ , ‘123abc’

This is incorrect because the second argument to the CustomEvent constructor must be an options object, not a string. The data would not be correctly attached.

C. { type : ‘update’, recordId : ‘123abc’ }

This uses a single object argument, which is an incorrect signature for the CustomEvent constructor. The event type must be the first string argument.

1. Salesforce Lightning Web Components Developer Guide:

Section: Communicate with Events > Create and Dispatch Events.

Content: The guide explicitly shows the correct syntax: const myEvent = new CustomEvent('eventname', { detail: { ... } });. This confirms that data must be passed in an object with a detail property. This invalidates options A, B, and C, and shows the case-sensitivity error in option D.

2. MDN Web Docs (Mozilla):

Document: CustomEvent() constructor.

Content: The documentation for the web standard defines the second parameter as an object, CustomEventInit, which can contain a detail property for passing data. It states, "The CustomEvent.detail read-only property returns any data passed when initializing the event." This confirms that properties other than detail (like Details in option D) will not be accessible via the standard mechanism.

In JavaScript, arrays are objects and are handled by reference. The line let finalMenu = foodMenu1; does not create a new array. Instead, it creates a new variable, finalMenu, that points to the exact same array in memory as foodMenu1. Therefore, when the push() method is called on finalMenu, it modifies this shared array. As a result, foodMenu1 will also reflect this change, containing the newly added element 'Garlic bread' at the end.

(Note: The option contains typos ('Burger', 'fires'), but it is the only choice that correctly reflects the structural modification of the array.)

Why Incorrect Options are Wrong

B. [ ‘pizza’,’Burger’, ‘French fires’]

This is incorrect because it fails to account for the modification made by finalMenu.push(), which affects the original array since both variables reference it.

C. [ ‘Garlic bread’ , ‘pizza’,’Burger’, ‘French fires’ ]

This is incorrect because the push() method adds elements to the end of an array, not the beginning. The unshift() method would produce this result.

D. [ ‘Garlicbread’]

This is incorrect. The push() method appends an element to an existing array; it does not replace the array's contents.

References

1. Mozilla Developer Network (MDN) Web Docs: The official documentation for JavaScript explains that objects (including arrays) are reference types. When assigned or passed, the "value" is a reference to the object.

Source: MDN Web Docs, JavaScript Guide > Grammar and types > Data structures and types.

Reference: "Objects are not compared by value... two distinct objects are not equal even if they have the same properties. Only comparing the same object reference with itself yields true." This principle underlies why modifying through finalMenu also modifies foodMenu1.

2. Mozilla Developer Network (MDN) Web Docs on Array.prototype.push(): This documentation confirms that the push() method modifies the array on which it is called.

Source: MDN Web Docs, JavaScript Reference > Standard built-in objects > Array > Array.prototype.push().

Reference: "The push() method adds one or more elements to the end of an array... The push method is a mutating method. It changes the length and the content of this."

3. Salesforce Lightning Web Components Developer Guide: The guide's section on reactivity explains how the framework handles changes to data, which is built upon core JavaScript principles of object references.

Source: Lightning Web Components Developer Guide > Reactivity > How Reactivity Works.

Reference: "The framework observes changes to the properties of an object... If you assign a new object to a property, the framework observes the new value. If you mutate an object or an array, the framework observes the new value." This reinforces that mutating an array (like with push) is a direct modification of the object in memory.

Explanation:

Z is equal to 3.14

Use strict has effect only on line 5.

Line 5 throws an error