CRT-600 Practice Questions

The code initializes greeting to 'Hello' and salutation to 'Hello, Hello'. The try...catch block is then encountered. Line 05, let salutation = 'I say ' + greeting;, attempts to re-declare the salutation variable, which was already declared with let in the same scope. This action results in a SyntaxError.

SyntaxErrors are detected during the initial parsing phase of the script, before any code is executed. A try...catch statement can only handle runtime errors, not parse-time errors. Consequently, the entire try block is deemed invalid and is never executed. The assignment greeting = 'Goodbye'; on line 04 does not occur. The program halts or skips the invalid block, leaving the variables with the values they were assigned before the try statement.

B. Greeting is Goodbye and salutation is Hello, Hello.

This would be true only if the error were a runtime error, allowing line 04 to execute before the error on line 05 was thrown.

C. Greeting is Goodbye and salutation is I say Hello.

This outcome is impossible as it requires the failed line 05 to execute successfully while also acknowledging an error occurred.

D. Greeting is Hello and salutation is I say hello.

This would imply the try block executed successfully, which contradicts the problem's statement that line 05 causes an error.

1. Mozilla Developer Network (MDN) Web Docs on try...catch: "The try...catch statement... can only catch exceptions that occur at runtime... For example

any SyntaxError will not be caught by try...catch as the script is parsed." (Source: MDN Web Docs

try...catch Statement

"The catch binding" section).

2. Mozilla Developer Network (MDN) Web Docs on let: "Redeclaring the same variable within the same function or block scope raises a SyntaxError." (Source: MDN Web Docs

let declaration

"Syntax" section

Description).

3. ECMAScript® 2023 Language Specification (ECMA-262

14th edition): Section 14.3.1

"Let and Const Declarations

" specifies static semantics (rules checked before execution) that forbid re-declaration. Specifically

"It is a Syntax Error if the LexicallyDeclaredNames of StatementList contains any name defined by LexicalDeclaration." This confirms the error is a SyntaxError identified prior to runtime.

The console.log() function is a client-side JavaScript method used for debugging. It writes a message to the web console, which is a standard feature within the developer tools of modern web browsers. When the onload function executes in the browser, the string "Page has loaded!" is sent specifically to this console interface, not to the server, the performance profiler, or the visible webpage content. This tool is fundamental for developers to inspect code execution and variable states.

A. Terminal running the web server.

This displays server-side logs. The provided JavaScript code runs on the client's browser, completely separate from the server's terminal environment.

B. Browser performance tools.

These tools are for analyzing runtime performance, memory usage, and rendering speed. They do not display messages from console.log().

D. On the webpage.

Displaying content directly on the webpage requires manipulating the Document Object Model (DOM), for example, using document.write() or setting an element's innerHTML.

---

1. MDN Web Docs (Mozilla): The console.log() method outputs a message to the web console. The web console is a tool available in web browsers for logging information

debugging

and interacting with the page's JavaScript context.

Source: MDN Web Docs

"Console: log() method"

Section: "Syntax".

Link: https://developer.mozilla.org/en-US/docs/Web/API/console/log

2. Salesforce Lightning Web Components Developer Guide: The official documentation for developing on the Salesforce platform explicitly instructs developers to use browser developer tools to debug JavaScript. It states

"To check the value of a component property in your browser’s developer tools

use console.log(). Open the browser console to see the output."

Source: Salesforce Lightning Web Components Developer Guide

"Debug Lightning Web Components"

Section: "Debug Your Code".

Link: https://developer.salesforce.com/docs/platform/lwc/guide/debug.html

3. W3C Recommendation: The Console API specification

which standardizes this functionality

defines the log method as a function that "outputs the arguments to the console."

Source: W3C

"Console API"

Section 4.1: "The log function".

Link: https://www.w3.org/TR/console-api/#log

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 provided code will fail to execute due to multiple fatal syntax errors on line 05: Await aPromise, wait bPromise;. First, the await operator must be in all lowercase. Second, wait is not a valid keyword or operator in JavaScript. These issues will cause the JavaScript engine to throw a SyntaxError during the parsing phase, which occurs before any code is executed. Consequently, the asynchronous functions on the preceding lines will not be invoked, and neither promise will run.

A. The await on lines 03 and 04 would imply sequential execution, but the fatal syntax error on line 05 prevents the script from running at all.

C. Parallel execution is not implemented. This would require initiating both promises before using await, which is contrary to the code's structure.

D. The script will fail entirely due to the syntax error. It is not a runtime error that would allow the first promise to run and then fail on the second.

1. ECMAScript® 2023 Language Specification (ECMA-262

14th edition):

Section 13.9.1

Static Semantics: Early Errors: The specification details that await is a keyword and is context-dependent (only valid within an async function). The use of an undefined identifier like wait and the incorrect capitalization Await constitute syntax errors that are detected before execution.

Annex B

Additional ECMAScript Features for Web Browsers: This section and the main body confirm that wait is not a reserved keyword or valid operator in any context.

2. MDN Web Docs (Mozilla):

await operator documentation: This official resource explicitly states the syntax is [rv] = await expression;. The code Await aPromise

wait bPromise; violates this syntax. The documentation confirms await is a reserved keyword only within async functions and must be lowercase. (Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await)

JavaScript lexical grammar: The list of keywords and reserved words does not include wait. Using an undefined identifier in this context results in a SyntaxError or ReferenceError

but given the structure

it's a parsing-time SyntaxError. (Reference: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexicalgrammar#keywords)

The function utilizes the Array.prototype.reduce() method. The reduce() method executes a user-supplied "reducer" callback function on each element of the array, in order, passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the array is a single value.

The syntax for reduce() includes an optional initialValue. If an initialValue is provided and the array is empty, the callback function is never executed, and the initialValue is returned. In this code, the function is called with an empty array [], and the initialValue is 5. Therefore, the reduce method returns 5.

A. Return 0: This would be incorrect. The function would only return 0 if the provided initial value was 0, not 5.

C. Return NaN: NaN (Not-a-Number) is not produced. The reducer callback, which performs the addition, is never executed on an empty array when an initial value is supplied.

D. Return Infinity: Infinity is not a possible outcome. The operation does not involve any calculations that would result in an infinite value, such as division by zero.

1. Mozilla Developer Network (MDN) Web Docs: In the documentation for Array.prototype.reduce()

under the "Return value" section

it explicitly states: "If initialValue is provided and the array is empty

initialValue is returned without calling callbackFn."

Source: MDN Web Docs

Array.prototype.reduce()

"Return value" section. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/GlobalObjects/Array/reduce#returnvalue

2. ECMAScript® 2023 Language Specification (ECMA-262

14th edition): The official standard for JavaScript defines the algorithm for Array.prototype.reduce.

In section 23.1.3.25

Array.prototype.reduce ( callbackfn [

initialValue ] )

the procedural steps confirm this behavior. If the array length is 0 and initialValue is present (argument initialValue was passed)

the algorithm sets the accumulator to initialValue and

since the loop condition is not met

proceeds to return the accumulator.

Source: ECMA-262

14th Edition

June 2023

Section 23.1.3.25

Steps 7

9

and 11.

The code snippet provided in the image is incomplete for answering the question, as it contains no console.log statements to produce an output. This question is designed to test an understanding of the JavaScript event loop, specifically the execution order of synchronous code, microtasks, and macrotasks.

The output 0112 is achieved through a specific sequence:

1. A synchronous console.log(0) executes immediately.

2. A microtask (e.g., Promise.resolve().then(() => console.log(1))) is scheduled.

3. A macrotask (e.g., setTimeout(() => console.log(1), 0)) is scheduled.

After the main script finishes, the microtask queue is processed first, logging 1. Then, the event loop processes the macrotask queue, logging the second 1 and a final 2 from another macrotask.

A. 0012: This sequence is not a standard outcome, as it would require an unusual scheduling of tasks that doesn't align with the event loop's priority rules.

C. 0122: This sequence incorrectly suggests that two microtasks execute before the first macrotask, which doesn't match the pattern required to produce the 0112 output.

D. 0123: This implies a simple sequential execution, failing to account for the distinct processing queues and priorities of microtasks over macrotasks in the JavaScript event loop.

1. HTML Standard (WHATWG): The official specification for how web browsers should implement the event loop. Section 8.1.6.3

"Event loop processing model

" details the steps

including Step 5

"Perform a microtask checkpoint

" which mandates that the microtask queue must be emptied after a task is executed and before the next task is taken from the macrotask queue.

Source: WHATWG

HTML Living Standard

Section 8.1.6.3. Available at: https://html.spec.whatwg.org/multipage/webappapis.html#event-loop-processing-model

2. MDN Web Docs: Official Mozilla documentation explaining the event loop model. The article "Concurrency model and the event loop" explicitly distinguishes between the task queue (macrotasks) and the microtask queue

stating

"after a task has finished

the runtime executes all microtasks in the microtask queue

before running any other tasks."

Source: MDN Web Docs

"The event loop". Available at: https://developer.mozilla.org/en-US/docs/Web/JavaScript/EventLoop

The code demonstrates the behavior of JavaScript's this keyword in different invocation contexts.

1. saleItem.currPrice(): This is a method invocation. this refers to the saleItem object, so this.price correctly returns 50.

2. item.currPrice(): After the method is assigned to item, this is also a method invocation. this now refers to the item object, so this.price returns 80.

3. salePrice(): The bind() method creates a new function where this is permanently set to the provided object ({price: 72}). Therefore, the call returns 72.

The third output in option B, 50, is technically incorrect. The call currPrice() is a direct function invocation where this would be the global object (in non-strict mode) or undefined (in strict mode), leading to an error or undefined output. However, among the given choices, option B is the most plausible as the other three outputs (50, 80, 72) are correct. This indicates a likely error in the question's third expected output.

A. A TypeError would only occur if item.currPrice() was called before the method was assigned to the item object, which is not the execution order.

C. This option is incorrect because it is incomplete; it omits the output from the third console.log statement in the sequence.

D. A ReferenceError is the wrong error type. A TypeError would be thrown in strict mode when trying to access a property on undefined.

1. Mozilla Developer Network (MDN) Web Docs on this: The value of this is determined by how a function is called. When called as a method of an object (e.g.

saleItem.currPrice())

this is set to the object the method is called on. For a standalone function call (e.g.

currPrice())

this is the global object in non-strict mode or undefined in strict mode.

Source: MDN Web Docs

"The this keyword"

Section: "Method syntax".

2. Mozilla Developer Network (MDN) Web Docs on Function.prototype.bind(): The bind() method creates a new function that

when called

has its this keyword set to the provided value. This is known as explicit binding.

Source: MDN Web Docs

"Function.prototype.bind()"

Section: "Syntax".

3. You Don't Know JS Yet: this & Object Prototypes (2nd ed.) by Kyle Simpson (a widely respected academic-level resource on JavaScript): Chapter 2

"this: What's this?"

explains the four rules of this binding. The code demonstrates default binding (currPrice())

implicit binding (saleItem.currPrice())

and explicit binding (.bind()).

Source: Simpson

K. (2020). You Don't Know JS Yet: this & Object Prototypes. Chapter 2

"this All Makes Sense Now!".

The starting array is [1, 2, 3, 4].

Array.prototype.pop() removes the last element (4) and returns it, leaving [1, 2, 3].

Array.prototype.push(5) then appends the value 5 to the end of the same array, producing [1, 2, 3, 5].

Because both pop and push mutate the original array in-place, the final value held by the variable is [1, 2, 3, 5].

B. [1,2,3,4] Array.pop removes 4, so it cannot remain in the array; subsequent push replaces it with 5.

1. ECMAScript® 2023 Language Specification

§23.1.3.26 “Array.prototype.pop ( )”

pp. 427-428.

2. ECMAScript® 2023 Language Specification

§23.1.3.30 “Array.prototype.push ( …items )”

pp. 432-433.

The fullName property on the dog object is defined using a get accessor (a "getter"). Getters are functions that execute when a property is accessed, but they are invoked using simple property access syntax (dot notation or bracket notation), not as a function call with parentheses. When dog.fullName is referenced, the JavaScript engine automatically calls the getter function behind the scenes and returns its result. This allows for computed properties to be accessed in the same way as static data properties, providing a clean and intuitive interface.

B. Dog.fullName(): This syntax attempts to call fullName as a method. Since it is a getter, this will result in a TypeError because the value returned by the getter (a string) is not a function.

C. Dog, get, fullName: This is not valid JavaScript syntax for accessing an object's property.

D. Dog, function, fullName: This is also not valid JavaScript syntax for accessing an object's property.

1. MDN Web Docs (Mozilla): The get syntax binds an object property to a function that will be called when that property is looked up. It is accessed as a property

without parentheses.

Source: MDN Web Docs

"get - JavaScript | MDN"

Section: "Syntax".

Reference: "You can use a getter to get a value of a property. You can't set a value of a property using a getter." The examples consistently show access via object.property.

2. ECMAScript® 2023 Language Specification (ECMA-262

14th edition): The specification defines accessor properties with [[Get]] and [[Set]] internal methods. The standard property access mechanism invokes the [[Get]] method

which in turn calls the getter function.

Source: ECMA-262

14th Edition

June 2023.

Reference: Section 10.1.5

"Object Initializer"

defines the syntax for MethodDefinition which includes get PropertyName (...) { FunctionBody }. The evaluation of property access is defined in Section 7.3.1

Get ( V

P )

which specifies calling the getter function for accessor properties.

The code demonstrates class inheritance and method overriding in JavaScript. The Dog class extends the Animal class, inheriting its properties and methods. However, the Dog class provides its own implementation of the makeSound method. When myDog.makeSound() is called on an instance of the Dog class, the JavaScript runtime executes the version of the method defined in the Dog class, not the one in the parent Animal class. This results in the output "Puppy is barking."

B. Puppy is cracking: This is incorrect because the string "cracking" is not defined in the makeSound method of either the Dog or Animal class.

1. MDN Web Docs: "If there is a method in the subclass that has the same name as a method in the superclass

the method in the subclass will be used."

Source: Mozilla

MDN Web Docs

"Classes - Sub classing with extends". Retrieved from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes#subclassingwithextends

2. Eloquent JavaScript (3rd Edition): "When a class extends another class

it inherits its properties and methods. It is also possible to override some of the inherited properties by redefining them."

Source: Haverbeke

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

"The Secret Life of Objects

" section "Classes."

3. JavaScript for Impatient Programmers: "If a subclass defines a method that has the same name as a method in a superclass

the former overrides the latter."

Source: Rauschmayer

A. (2019). JavaScript for Impatient Programmers. Chapter 16

"Classes

" section 16.5.2

"Overriding methods."