JavaScript-Developer-I Sample Questions Answers

We call:

myFunction([]);

Inside:

arr.reduce((result, current) = > {

return result + current;

}, 10);

Key points about Array.prototype.reduce:

Signature: array.reduce(callback, initialValue)

If initialValue is provided and the array is empty , reduce:

Does not call the callback at all.

Simply returns initialValue.

Here:

arr is [] (empty).

initialValue is 10.

So:

No iterations of the callback happen (no elements to process).

The return value is the initial value: 10.

So the actual output is:

myFunction([]) === 10;

Among the options:

A: 0 – incorrect, because the initial value is 10, not 0.

B: Throws an error – reduce throws only if the array is empty and there is no initialValue. Here we have an initial value, so no error.

C: NaN – there is no arithmetic with undefined or invalid values; we just return 10.

D: Returns 5 – the numeric value given is wrong; the correct value is 10.

Given the logic, the correct conceptual result is 10 . The option text “Returns 5” is almost certainly a typo for “Returns 10”. Since the letter that is intended to represent the correct behavior is D, we keep:

Answer: D

Study Guide / Concept References (no links):

Array.prototype.reduce behavior with initialValue

Behavior of reduce on an empty array with and without initialValue

Return value when no iterations run

1. Getter Functions in JavaScript

In JavaScript, when an object uses the get keyword, it defines a getter method . Accessing a getter property executes the function and returns its value. Thus:

o.js

does not return the getter function; instead, it executes the function located at:

get js() { ... }

and returns the object inside the return block.

2. Behavior of String() and toLowerCase()

Inside the getter:

let city1 = String( ' St. Louis ' );

let city2 = String( ' New York ' );

String() creates a string value.

Then, the returned object is constructed as:

{

firstCity: city1.toLowerCase(),

secondCity: city2.toLowerCase(),

}

The method toLowerCase() is a standard JavaScript string method that returns a new string with all alphabetic characters converted to lowercase .

Therefore:

city2.toLowerCase()

returns:

' new york '

3. Referencing the Property

When the developer writes:

o.js.secondCity

the following happens:

The getter js runs and returns an object.

The returned object includes the property:

secondCity: ' new york '

Accessing .secondCity retrieves the lowercase string ' new york ' .

Therefore, the correct value is ' new york ' .

Why the Other Options Are Incorrect

A. undefined – incorrect because the property secondCity clearly exists in the returned object.

B. An error – incorrect because no invalid operations occur; all methods and properties are valid.

C. ' New York ' – incorrect because toLowerCase() transforms the string to lowercase.

JavaScript Knowledge References (Text-Based)

Getter methods using the get keyword return computed values when accessed.

JavaScript String values support the toLowerCase() method, which returns a lowercase version of the original string.

Accessing nested properties like o.js.secondCity triggers the getter, returning the constructed object.

The verified corrected answers are C, D, and E .

This function is a normal function, not a curried function:

function sum(num1, num2, num3) {

if (num3 === undefined) {

num3 = 0;

}

return num1 + num2 + num3;

}

It expects values to be passed in the same function call:

sum(num1, num2, num3);

Now check the valid corrected options.

Option C:

sum(5, 5, 0);

Calculation:

5 + 5 + 0

Result:

10

So C is correct .

Option D:

sum(10, 0);

Here, num3 is not provided, so it is undefined.

The function checks:

if (num3 === undefined) {

num3 = 0;

}

So the calculation becomes:

10 + 0 + 0

Result:

10

So D is correct .

Option E:

sum(5, 2, 3);

Calculation:

5 + 2 + 3

Result:

10

So E is correct .

Why A and B are incorrect as originally written:

sum(5)(5);

This calls sum(5) first. Since num2 is missing, the result becomes NaN. Then JavaScript tries to call that returned value as a function, which causes a TypeError.

sum()(10);

This also calls sum() first, producing NaN, and then attempts to call NaN as a function.

Those styles would only work if sum were written as a curried function, but the given implementation is not curried.

Therefore, the verified corrected answers are C, D, and E .

console.log() in browser-side JavaScript writes output to the browser’s JavaScript console , which is available in the browser’s Developer Tools.

In a typical browser (Chrome, Firefox, Edge, etc.), you open DevTools and go to the Console tab.

Any console.log( " Page has loaded! " ); executed in page JavaScript will appear there.

Why A is correct:

The function onLoad is a client-side function (runs in the browser).

When it executes, the console.log call goes to the browser’s JavaScript console , not the server.

Why the others are incorrect:

B. On the terminal console running the web server

That console shows logs from the server-side runtime (e.g., Node.js logs).

This code is clearly browser-side JavaScript (no Node.js or server context shown).

Therefore, the output does not appear in the terminal.

C. In the browser performance tools log

Performance tools (Timeline, Performance tab, etc.) show metrics about rendering, CPU time, network, etc., not generic console.log messages.

console.log messages appear in the Console tab, not in performance logs.

D. On the webpage console log

There is no built-in concept of a “webpage console log” UI rendered on the page itself by default.

Unless you explicitly code something to display logs in the DOM, console.log output is not visible on the page, only in Developer Tools.

Therefore, the correct place to see that log is:

Answer: A

JavaScript knowledge / Study Guide references (concept names only, no links):

Browser Developer Tools – Console tab

console.log() in client-side JavaScript

Difference between client-side logs and server-side logs

First, recall the fizzbuzz rules:

If n divisible by 3 and not by 5 → return ' fizz ' .

If n divisible by 5 and not by 3 → return ' buzz ' .

If n divisible by both 3 and 5 → return ' fizzbuzz ' .

Otherwise → return ' ' (empty string).

Evaluate each test:

Option A:

let res = fizzbuzz(true);

console.assert(res === ' ' );

In JavaScript, when using arithmetic operations with true, it is coerced to the number 1. A typical implementation of fizzbuzz would treat the argument as a number and compute:

true % 3 → 1 % 3 → 1

true % 5 → 1 % 5 → 1

So true is effectively treated as 1, which is divisible by neither 3 nor 5. The function should return ' ' . The assertion res === ' ' will pass.

This test covers the scenario “neither divisible by 3 nor 5”.

Option B:

let res = fizzbuzz(3);

console.assert(res === ' ' );

3 is divisible by 3 but not by 5.

According to fizzbuzz rules, fizzbuzz(3) should return ' fizz ' .

This test expects ' ' , so it is incorrect; the assertion would fail in a correct implementation.

Option C:

let res = fizzbuzz(5);

console.assert(res === ' fizz ' );

5 is divisible by 5 but not by 3.

According to fizzbuzz rules, fizzbuzz(5) should return ' buzz ' .

This test expects ' fizz ' , so it is incorrect.

Option D:

let res = fizzbuzz(15);

console.assert(res === ' fizzbuzz ' );

15 is divisible by both 3 and 5.

According to fizzbuzz rules, fizzbuzz(15) should return ' fizzbuzz ' .

This assertion correctly matches the expected result, so it is a proper test case.

Thus, the two test cases that correctly test valid fizzbuzz behavior are:

Answer: A, D

Study Guide / Concept References (no links):

Modulo operator (%) for divisibility checks

Truthy/number coercion of boolean true in arithmetic (Number(true) === 1)

Designing unit tests with console.assert

Typical fizzbuzz logic structure and expected outputs

console.log( ' Start ' ) runs immediately (synchronous).

Promise.resolve().then(...) places the callback in the microtask queue. The .then handler does not run immediately.

console.log( ' End ' ) runs next (still synchronous).

After the synchronous script finishes, the microtask queue runs, logging " Success " .

Execution order:

Start

End

Success

This matches option B .

JavaScript Knowledge References (text-only)

Promise .then() callbacks execute after the current call stack finishes (microtask queue).

Synchronous logs run immediately, before promise callbacks.

==================================================

A correct conversion from constructor-function syntax to ES6 class syntax must satisfy:

Use a constructor(name, price) method.

Assign instance properties inside the constructor.

Define methods without function keyword directly in the class body.

Use proper JavaScript template literals (backticks).

Evaluate each option:

Option A

Incorrect template literal syntax: uses single quotes with ${} which will not interpolate.

Option B

Incorrect:

The method vehicle() is not recognized as a constructor.

The constructor method is missing.

Option C

Incorrect:

The constructor has no parameters, but uses name and price which are undefined.

Option D

Correct:

Uses proper constructor with parameters.

Correct assignment of instance properties.

Correct template literal using backticks.

This is the valid ES6 class translation.

JavaScript Knowledge References (text-only)

ES6 classes require a constructor method for initialization.

Template literals must use backticks.

Methods inside classes are defined without the function keyword.

Omitted constructor parameters lead to undefined instance fields.

In the getter:

let city = Number( " London " );

The Number() constructor attempts to convert the string " London " into a numeric value.

" London " is not a valid numeric string. When JavaScript attempts numeric conversion of a non-numeric string:

Number( " London " ) → NaN

Next line:

city.toString()

When city is NaN, calling .toString() yields:

NaN.toString() → " NaN "

The getter returns:

{

cityString: " NaN "

}

The question asks: Which value can a developer expect? The multiple-choice options include NaN , but not " NaN " .

Given the available choices, the intended correct answer is B (NaN) because the root cause is the Number( " London " ) conversion returning NaN.

JavaScript Knowledge References (text-only)

Number(nonNumericString) returns NaN.

NaN.toString() produces " NaN " .

Getters compute and return their values each time the property is accessed.

==================================================

A recursive function is a function that calls itself and has a base case to terminate the recursion.

Evaluate each option:

Option A:

const sumToTen = numVar = > {

if (numVar < 0)

return;

return sumToTen(numVar + 1);

};

This function calls itself: sumToTen(numVar + 1) — so it is recursive.

However, the base condition is if (numVar < 0) return;.

If you call sumToTen(0):

numVar < 0 is false, so it calls sumToTen(1), then sumToTen(2), and so on, incrementing forever.

There is no condition to stop the recursion when numVar increases; it will eventually cause a stack overflow.

This code does not represent a properly working recursive function with a valid termination for increasing values and is not a good example of correct recursion.

Option B:

function factorial(numVar) {

if (numVar < 0) return;

if (numVar === 0) return 1;

return numVar - 1;

}

This function does not call itself anywhere.

It has conditional returns, but there is no recursive call such as factorial(numVar - 1).

Therefore, it is not recursive at all.

Option C:

const factorial = numVar = > {

if (numVar < 0) return;

if (numVar === 0) return 1;

return numVar * factorial(numVar - 1);

};

This is a classic recursive factorial implementation.

It calls itself with a smaller argument: factorial(numVar - 1).

Base cases:

If numVar < 0, it simply returns (could be treated as invalid input).

If numVar === 0, it returns 1, which is the mathematical definition of 0! (zero factorial).

For positive integers, it correctly multiplies numVar by factorial(numVar - 1) until it reaches the base case.

This is a correct and working recursive function.

Option D (corrected):

let countingDown = function(startNumber) {

if (startNumber > 0) {

console.log(startNumber);

return countingDown(startNumber - 1);

} else {

return startNumber;

}

};

This function also calls itself: countingDown(startNumber - 1).

Base case:

When startNumber is not greater than 0 (i.e., 0 or negative), it returns startNumber and stops recursing.

For example, countingDown(3) would:

Log 3, call countingDown(2)

Log 2, call countingDown(1)

Log 1, call countingDown(0)

At 0, it hits the else branch and returns 0, ending the recursion.

This is a valid working recursive function structure (once syntax is corrected).

Therefore, the snippets that show working recursive functions are:

Answer: C, D

Study Guide / Concept References (no links):

Definition of recursion: a function calling itself

Base case vs recursive step

Recursive factorial implementation

Recursive countdown example

Importance of a terminating condition to avoid infinite recursion

From earlier pattern (cars/cats race):

One promise resolves the fastest with " Car 2 completed " (or analogous " Cat 2 completes " ).

Promise.race resolves with the first settled promise’s value.

In .then, value is " Car 2 completed " and:

let result = `${value} the race.`;

// " Car 2 completed the race. "

Thus result is " Car 2 completed the race. " → option A.

To schedule a function for later execution in JavaScript, the standard built-in method is:

setTimeout(functionReference, delayInMilliseconds)

Characteristics of setTimeout():

Executes only once .

Delay is specified in milliseconds.

Requires passing the function reference , not calling the function.

Two minutes is:

2 minutes = 120 seconds = 120,000 milliseconds

Now evaluate each option:

Option A: delay(sayHello, 120000);

Incorrect.

There is no built-in delay() function in JavaScript.

Option B: setTimeout(sayHello, 120000);

Correct.

sayHello is passed as a function reference , so it will execute once after 120,000 ms.

Option C: setTimeout(sayHello(), 120000);

Incorrect.

sayHello() calls the function immediately , and the return value (undefined) is passed to setTimeout.

This executes the function right away instead of after two minutes.

Option D: setInterval(sayHello, 120000);

Incorrect.

setInterval() repeats execution every 120,000 ms.

The question requires executing the function once , so this cannot be correct.

JavaScript Knowledge References (text-only)

setTimeout() schedules a function to run once after a specified delay.

Passing functionName gives a reference; passing functionName() invokes it immediately.

setInterval() repeats indefinitely, unlike setTimeout().

==========================================

The verified answer is A .

This constructor function runs when new Person() is called:

function Person() {

this.firstName = " John " ;

}

So this line:

const myFather = new Person();

creates an object like this:

{

firstName: " John "

}

Then the prototype is assigned a method named job:

Person.prototype = {

job: x = > " Developer "

};

Because myFather is created from Person, it can access properties and methods from Person.prototype.

So:

myFather.firstName

returns:

" John "

And:

myFather.job()

returns:

" Developer "

Therefore:

const result = myFather.firstName + " " + myFather.job();

becomes:

const result = " John " + " " + " Developer " ;

Final value:

" John Developer "

Option B is incorrect because job() returns " Developer " , not undefined.

Option C is incorrect because job exists on Person.prototype, so it is callable.

Option D is incorrect because firstName is assigned inside the constructor.

Therefore, the verified answer is A .

Requirement:

The message should be displayed only on the first click of the button.

Original behavior:

The handler listen is attached with button.addEventListener( ' click ' , listen);.

That means listen is called on every click until the listener is removed or configured otherwise.

Two correct ways to ensure the listener only fires once:

Use the once option in addEventListener

Remove the event listener after the first run inside the handler

Option C:

On line 06, add an option called once to button.addEventListener().

This means modifying line 06 to:

button.addEventListener( ' click ' , listen, { once: true });

The once: true option tells the browser:

Call the listen function at most once.

After it is called the first time, automatically remove the listener.

So:

First click: alert shows, listener is removed automatically.

Subsequent clicks: no further calls to listen, no alerts.

This satisfies the requirement.

Option D:

On line 04, use button.removeEventListener( ' click ' , listen);

This means updating the handler:

function listen(event) {

alert( ' Hey! I am John Doe ' );

button.removeEventListener( ' click ' , listen);

}

Now:

On the first click, listen is executed:

It shows the alert.

It removes itself from the button’s click listeners.

On subsequent clicks, listen is no longer registered, so nothing happens.

This also satisfies the requirement.

Why A and B are incorrect:

Option A:

On line 04, use event.stopPropagation();

event.stopPropagation() stops the event from bubbling up the DOM tree.

It does not prevent the current listener from being called again in the future.

The click handler will still run on every click; it just prevents other listeners higher in the DOM from receiving the event.

Option B:

On line 02, use event.first to test if it is the first execution.

There is no built-in event.first property in standard DOM events.

This property does not exist and will be undefined.

You would need your own external flag (let hasRun = false;) to track first execution, but that is not what B describes.

Therefore, the two correct modifications are:

Answer: C, D

Study Guide / Concept References (no links):

addEventListener options object: { once: true }

removeEventListener to manually deregister event handlers

Event propagation (event.stopPropagation) vs handler lifecycle

DOM event model and listener registration

The correct answer is C .

The typing errors in the options should be corrected as follows:

event.stopPropagation();

The stopPropagation() method is used to stop an event from continuing through the DOM event propagation path.

A click event normally goes through these phases:

Capturing phase → Target phase → Bubbling phase

Because the event listener is attached to the button:

el.addEventListener( " click " , printMessage, false);

the function printMessage receives the click event when the button is clicked. To stop the event from bubbling up to parent elements, the event object should be accepted as a parameter and stopPropagation() should be called inside the event handler.

Corrected code:

< html >

< body >

< div id= " logo " > Hello Logo! < /div >

< button id= " test " > Click me < /button >

< /body >

< script >

function printMessage(event) {

event.stopPropagation();

console.log( ' This is a test message ' );

}

let el = document.getElementById( ' test ' );

el.addEventListener( " click " , printMessage, false);

< /script >

< /html >

Why this is correct:

event.stopPropagation();

prevents the click event from moving upward to ancestor elements after the button’s handler runs.

Why the other options are incorrect:

A and B are incorrect because removeEventListener() is used to remove a previously registered event listener. It does not stop event bubbling for the current event.

D is incorrect because stopPropagation() should be called inside the active event handler that receives the event object. In this case, that function is:

printMessage(event)

Therefore, the verified answer is C .

Node.js includes a built-in command-line (CLI) debugger . To use it directly in the terminal, the standard command is:

node inspect server.js

This:

Starts server.js under the Node.js inspector.

Opens the CLI debugger right in the terminal window where you ran the command.

Lets you interactively:

Step through code

Set breakpoints

Inspect variables

Continue execution, etc.

Why B is correct:

Option B (corrected to node inspect server.js) is exactly the standard Node.js command to run a script under the CLI debugger in the current terminal.

It does not rely on any external GUI tools.

You stay entirely in the terminal to debug.

Why the other options are incorrect:

A. node start inspect server.js

There is no start subcommand like this in standard Node.js CLI.

This is not a valid Node.js debugging command.

C. node server.js --inspect

This starts Node.js with the Inspector protocol enabled and is typically used to connect external tools like Chrome DevTools or VS Code.

It does not open the CLI debugger in the current terminal. Instead, it opens a debugging port that other tools attach to.

The question specifically says “only using the terminal” and “open the CLI debugger in their current terminal window”, which points to node inspect, not --inspect.

D. node -i server.js

-i starts Node in interactive REPL mode , optionally after running a script.

This is for an interactive shell, not the Node debugger.

It does not provide breakpoint/step/next/continue debugging features like the CLI debugger.

Therefore, the only option that opens the Node.js CLI debugger in the current terminal is:

Answer: B

JavaScript / Node.js knowledge / Study Guide references (concept names only, no links):

Node.js CLI debugger: node inspect < script >

Node.js inspector protocol: node --inspect

Difference between CLI debugger and DevTools-based debugging

Node.js command-line options and subcommands

import * as lib from ' ... ' imports all named exports from the module into the namespace object lib.

You then call:

lib.foo();

lib.bar();

Option D correctly imports only foo and bar, not every function. The question explicitly says “import every function… and then call foo and bar”, so A best matches.

Options B and C are invalid syntax or reference the wrong identifier.

Evaluate each test:

A. sum3([1, ' 2 ' ])

Array length is 2 → line 4: arr[0] + arr[1] → 1 + ' 2 ' → ' 12 ' (string).

Assertion: ' 12 ' == 12 is true (type coercion). However, this “test” is not logically correct: a numeric sum function should not be expected to return ' 12 ' as a string. It passes only because of weak equality coercion, so it is not a good/valid test of correct behavior.

B. sum3([ ' hello ' , 2, 3, 4])

Length ≥ 3 → line 5: ' hello ' + 2 + 3 → ' hello2 ' + 3 → ' hello23 ' .

' hello23 ' === NaN is always false because NaN is never equal to anything, not even itself. This assertion fails and also misunderstands how NaN comparisons work.

C. sum3([-3, 2])

Length 2 → -3 + 2 = -1.

Assertion: -1 === -1 → true. This is a correct and meaningful test.

D. sum3([0])

Length 1 → returns arr[0] → 0.

Assertion: 0 === 0 → true. Also a correct and meaningful test.

Therefore, the valid and logically correct tests here are C and D.

str = ' Salesforce '

Index positions:

S(0) a(1) l(2) e(3) s(4) f(5) o(6) r(7) c(8) e(9)

substring(start, end)

Start index inclusive, end index exclusive.

str.substring(0, 5) → characters at indices 0–4 → " Sales "

str.substring(1, 5) → indices 1–4 → " ales "

substr(start, length)

Start index, then number of characters.

str.substr(0, 5) → 5 characters starting at index 0 → " Sales "

str.substr(1, 5) → 5 characters from index 1 → " alesf "

So the expressions that return " Sales " are A and C.

The correct answer is D , because JavaScript executes synchronous code first, while the code after await runs later after the Promise resolves.

The execution order is:

console.log(2);

This runs first, so JavaScript logs:

2

Then this line runs:

asyncCall();

The asyncCall() function starts executing. Inside it, JavaScript reaches:

await delay(1000);

The delay(1000) function returns a Promise that resolves after 1000 milliseconds:

return new Promise(resolve = > {

setTimeout(resolve, delay);

});

Because await pauses the rest of the asyncCall() function, this line does not run immediately:

console.log(1);

Instead, JavaScript continues executing the remaining synchronous code outside the async function:

console.log(3);

So JavaScript logs:

3

After approximately 1000 milliseconds, the Promise returned by delay(1000) resolves. Then the paused async function continues and runs:

console.log(1);

So JavaScript logs:

1

Final console output:

2

3

1

Important JavaScript concepts involved:

An async function always returns a Promise.

The await keyword pauses execution only inside the async function where it appears.

Code outside the async function continues running normally.

setTimeout() schedules its callback to run later, after the current synchronous code has finished.

Therefore, the verified answer is D. 2 3 1 .

The correct answers are A and B .

The original question contains a typing error where 66 should be corrected to the logical AND operator:

& &

A is correct because it first evaluates the logical AND expression and then converts the final result to a Boolean:

Boolean(exp1 & & exp2)

The & & operator returns the first falsy value or the last truthy value. Wrapping the result in Boolean() ensures the final result is strictly either:

true

or:

false

Example:

Boolean( " hello " & & 123);

This returns:

true

B is also correct because it converts both expressions to Boolean values first, then applies logical AND:

Boolean(exp1) & & Boolean(exp2)

This guarantees that both sides of the & & operation are Boolean values.

Example:

Boolean( " hello " ) & & Boolean(123);

This returns:

true

C is incorrect because it uses the bitwise AND operator:

&

This is not the same as logical AND:

& &

Bitwise AND converts values into numbers and compares their binary representation. It does not reliably return a Boolean logical result.

D is incorrect as written because the question gives the expressions as exp1 and exp2, but option D uses var1 and var2. After correction, it would be the same idea as option B.

Therefore, the verified answers are A and B .

Currently:

sayHello expects a value name and prints it.

world is a function that returns ' World ' .

sayHello(world); passes the function object itself, not the result of calling it.

So name inside sayHello is a function, not the string " World " .

To keep the call sayHello(world) yet get " World " , sayHello must call the function parameter:

const sayHello = (name) = > {

console.log( ' Hello ' , name());

};

Now:

sayHello(world) passes the function.

Inside sayHello, name() calls world(), which returns " World " .

The console logs " Hello World " .

Why the others are wrong:

B: Changing line 7 to }(); would attempt to IIFE the function definition and break the declaration.

C: sayHello(world)() would try to call the return value of sayHello, which is undefined, causing an error.

D: Changing world to a function declaration does not change the fact that it is passed as a function reference; sayHello still prints the function object, not ' World ' .

Semantic versioning: MAJOR.MINOR.PATCH

MAJOR: incompatible API changes.

MINOR: add functionality in a backward compatible manner.

PATCH: backward compatible bug fixes.

Here:

Bug fixes only, no breaking changes → increment PATCH.

From 2.1.1 to 2.1.2.

So the correct new version is 2.1.2.

Requirement:

getNextValue() should run only if handleObjectValue(x) does not throw an error.

If an error occurs, handleError(error) should run, and getNextValue() should be skipped.

Option B:

try {

handleObjectValue(x);

getNextValue();

} catch (error) {

handleError(error);

}

Behavior:

If handleObjectValue(x) succeeds (no error):

Execution continues to getNextValue();.

If handleObjectValue(x) throws:

Control jumps directly to catch, getNextValue() is skipped.

handleError(error); is called.

This matches the requirement perfectly.

Why others are incorrect:

A: } then { is invalid JavaScript syntax.

C:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

}

getNextValue();

getNextValue() is called after the try...catch regardless of whether an error occurred. Not acceptable.

D: finally always runs:

try {

handleObjectValue(x);

} catch (error) {

handleError(error);

} finally {

getNextValue();

}

getNextValue() will execute in both success and error cases.

Therefore, the correct approach is B.

Concepts: try/catch control flow, finally semantics, placing code inside vs outside try/catch blocks.

Arrow functions have two defining characteristics:

Implicit return when written as a single expression:

const fn = () = > 5; // returns 5 automatically

This is unique to arrow functions → A is correct.

Lexical this binding : Arrow functions do not create their own this. Instead, they use the this value from the surrounding scope → B is correct.

Incorrect options:

C is false: There is no special argument called parentThis.

D is the opposite of arrow function behavior: Normal functions create their own this; arrow functions do not.

JavaScript Knowledge References (text-only)

Arrow functions have lexical this binding.

Arrow functions support implicit return for single expressions.

==================================================

JavaScript consoles (browsers and Node) provide timing utilities:

console.time(label) – starts a timer with the given label.

console.timeEnd(label) – stops the timer and logs the total elapsed time.

console.timeLog(label) – logs the current elapsed time without stopping the timer.

To measure the time taken by each function separately while still using a single overall timer, you can log intermediate times:

console.time( ' Performance ' );

maybeAHeavyFunction();

console.timeLog( ' Performance ' , ' after maybeAHeavyFunction ' );

thisCouldTakeTooLong();

console.timeLog( ' Performance ' , ' after thisCouldTakeTooLong ' );

orMaybeThisOne();

console.timeLog( ' Performance ' , ' after orMaybeThisOne ' );

console.timeEnd( ' Performance ' );

Each console.timeLog( ' Performance ' ) call prints the elapsed time since console.time( ' Performance ' ) was started, so you can infer how long each function took.

Note: console.endTime in the original snippet is incorrect; the real method is console.timeEnd.

Why other options are incorrect:

B. console.trace()

Prints a stack trace, not timing information.

C. console.timeStamp()

Used with browser performance tools; it does not directly show elapsed times like timeLog or timeEnd.

D. console.getTime()

Not a standard console method.

Thus, the function that can be used to obtain timing between calls is:

Answer: A

Study Guide Concepts:

console.time, console.timeLog, console.timeEnd

Measuring performance and intermediate timings

Standard console debugging API methods

Node.js provides two built-in modules for creating servers:

http → creates non-secure HTTP servers

https → creates secure HTTPS servers

A secure server requires:

SSL/TLS certificates (key and cert)

The built-in Node.js module designed to handle these: https

Syntax for a secure server:

const https = require( ' https ' );

const fs = require( ' fs ' );

const options = {

key: fs.readFileSync( ' key.pem ' ),

cert: fs.readFileSync( ' cert.pem ' )

};

https.createServer(options, (req, res) = > {

res.write( ' Secure Server ' );

res.end();

}).listen(443);

Evaluation of options:

A is incorrect: No built-in module named secure-server exists.

B is incorrect: tls provides low-level TLS sockets, not HTTP/HTTPS servers.

C is incorrect: http only creates an insecure server.

D is correct: https is the built-in module required for secure web servers.

JavaScript Knowledge References (text-only)

Node.js exposes built-in modules http and https for server creation.

Secure servers require the https module, which supports TLS/SSL.

The tls module is lower-level and not used for full HTTP servers.

==================================================

Comprehensive and Detailed Explanation:

The loop removes every 4:

Start: [1, 2, 3, 4, 4, 5, 4, 4]

i=0 → 1 (no change)

i=1 → 2 (no change)

i=2 → 3 (no change)

i=3 → 4 → splice removes index 3 → [1,2,3,4,5,4,4], then i-- → 2

Next loop, i=3 → 4 again → splice → [1,2,3,5,4,4], i-- → 2

i=3 → 5 (no change)

i=4 → 4 → splice → [1,2,3,5,4] , i-- → 3

i=4 → 4 → splice → [1,2,3,5], i-- → 3

Next i=4, array.length is 4 → loop ends.

All 4s removed, final array: [1, 2, 3, 5].

The answer choices appear to belong to an event propagation question using nested elements such as an outer element and an inner element.

The important clue is this third argument:

addEventListener( ' click ' , handlerFunction, true);

When the third argument is true, the event listener runs during the capturing phase .

In event capturing, the browser handles the event from the outside toward the inside:

Outer element → Inner element

So, if an inner element is clicked and both the outer and inner elements have click listeners registered with capture mode set to true, the outer listener runs first, then the inner listener runs.

That produces:

Outer message

Inner message

So the matching option is B .

Important correction:

In the exact code shown, the buttons are sibling elements:

< button class= " secondary " > Save draft < /button >

< button class= " primary " > Save and close < /button >

They are not nested inside one another. Therefore, with the code exactly as written:

Clicking the secondary button logs:

Save message.

Clicking the primary button logs:

Success message.

However, because the provided answer choices refer to Outer message and Inner message , the intended concept is clearly event capturing. In a capturing-phase question with nested outer and inner elements, the correct order is:

Outer message

Inner message

Therefore, the verified answer for the intended event-capturing question is B .

We want to select the first < li > under #main and change its content.

document.querySelector(selector) returns the first element matching the CSS selector.

In the DOM, the < li > elements under < ul > are children in order:

1st child: " Leo "

2nd child: " Tony "

3rd child: " Tiger "

li:nth-child(1) is the CSS pseudo-class that selects the first < li > inside its parent.

So:

document.querySelector( ' #main li:nth-child(1) ' ).innerHTML = ' The Lion ' ;

selects the first < li > ( " Leo " ) inside #main and sets its innerHTML to " The Lion " .

Why others are incorrect:

A. #main #Leo

There is no element with id " Leo " . id is not set on the < li > , so the selector matches nothing.

B. li:second-child

There is no :second-child pseudo-class. The valid pseudo-class is :nth-child(2); and that would select " Tony " , not " Leo " .

C. ' #main li,Leo '

This selector means “all #main li and all elements named < Leo > ”.

There is no < Leo > tag, and querySelectorAll returns a NodeList, which does not have a single innerHTML property.

Therefore, D is the correct statement.

Study Guide Concepts:

document.querySelector vs querySelectorAll

CSS selectors: nth-child()

DOM element innerHTML property

objA is { value: 10 }.

objB = objA; → both variables reference the same object .

changeValue(objB);:

obj.value = obj.value / 2; // modifies the shared object

So:

objA.value becomes 10 / 2 = 5.

Thus result is 5.

Definitions:

False negative → The test reports a failure even though the feature actually works.

False positive → The test reports success when it should not.

True positive → Correctly identifies something is working.

True negative → Correctly identifies something is not working.

In this scenario:

The checkout button does exist , so the feature works.

The test fails incorrectly , because it is checking for the wrong selector.

That is the definition of a false negative .

JavaScript Knowledge References (text-only)

Test outcome classification: false negative = feature works but test fails.

==================================================

In JavaScript, there is only one numeric type for ordinary numbers: number.

JavaScript number is a double-precision 64-bit binary format (IEEE 754).

There is no separate float, double, or decimal type in core JavaScript.

So:

typeof pi === ' number ' ;

Hence, the correct answer is:

A. Number

Options B, C, D are specific numeric types found in other languages (like C, Java, C#), not distinct types in JavaScript.

Study Guide Concepts:

JavaScript primitive types

typeof operator and number

Lack of separate float / double / decimal types in JS

Key JavaScript Promise rule:

try...catch does not catch asynchronous errors that occur in Promise chains.

Therefore, the correct way to handle errors in a Promise is:

promise.then(...).catch(...);

Analysis of options:

A and B: Both wrap asynchronous code in try...catch, which does not catch Promise rejections. try...catch only catches errors thrown synchronously inside the block.

C: Correct. A .catch() on the Promise chain handles any error from the Promise returned by requestPromise().

D: .finally() executes regardless of success or failure, but it does not receive the error object , so it cannot handle the error.

Thus the only valid solution is option C .

JavaScript Knowledge References (text-only)

Promise rejections must be handled with .catch().

try...catch only handles synchronous code.

.finally() does not receive a rejection reason.

==================================================

We have an array of plain objects:

[

{ name: ' John ' , email: ' john@email.com ' },

{ name: ' Jane ' , email: ' jane@email.com ' },

{ name: ' Emily ' , email: ' emily@email.com ' }

]

We want:

A “visual representation” of the list.

Ability to sort by name or email in DevTools.

console.table:

console.table(data) renders data as a table in most browser devtools and Node consoles that support it.

Each object becomes a row; properties (name, email) become columns.

Many DevTools UIs allow:

Clicking column headers to sort by that column.

Filtering / viewing in a structured way.

So:

console.table(usersList);

Displays a sortable table of users by name or email. This matches the requirement exactly.

Other options:

console.group(usersList);

Starts a console group. The argument is just logged as a line label.

It does not create a table or sortable view; it just groups subsequent logs.

console.groupCollapsed(usersList);

Same grouping behavior, but collapsed by default.

Again, no table or sortable columns.

console.info(usersList);

Logs the array in the console, but as a standard log/info.

You can expand objects, but there is no table view or built-in column sorting.

Therefore, the correct method is:

Answer: A

Study Guide / Concept References (no links):

console.table for tabular logging

console.group and console.groupCollapsed for grouped logs

console.log / console.info standard logging behavior

DevTools UI support for sorting columns in console.table

Two key browser events:

DOMContentLoaded (fired on document): Fired when the HTML document has been completely loaded and parsed, without waiting for stylesheets, images, and subresources to finish loading.

load (fired on window): Fired when the entire page is fully loaded, including all dependent resources such as stylesheets and images.

The requirement states:

“… when the webpage is fully loaded with HTML content and all related files.”

That matches the semantics of the load event on the window object.

So the correct code is:

window.addEventListener( ' load ' , personalizeWebsiteContent);

Why others are incorrect:

A: DOMContentLoaded fires earlier, when HTML is parsed, but before all related files (images, some styles, etc.) are guaranteed to be loaded.

B: ' onDOMContentLoaded ' is not a valid event name; the event is ' DOMContentLoaded ' .

D: When using addEventListener, the event type is ' load ' , not ' onload ' . ' onload ' is the name of the handler property (window.onload = ...), not the event string.

Relevant concepts: window.load event, DOMContentLoaded, addEventListener syntax, page load lifecycle.

ES Modules follow these rules:

Default exports are imported using:

import anyName from ' module '

The name chosen in the import does NOT need to match the exported name.

If a module exports:

export default function printDate() {}

then consuming code should import the function directly:

import printDate from ' /path/DatePrettyPrint.js ' ;

To execute it:

printDate();

Option analysis:

A incorrect: import DatePrettyPrint() is invalid syntax. Also calling printDate() without importing it is incorrect.

B incorrect: A default export imported as DatePrettyPrint gives the function itself, not an object containing methods. You cannot call DatePrettyPrint.printDate().

C incorrect: Imports printDate but then calls DatePrettyPrint.printDate(), which does not exist.

D correct: Correct import of a default-exported function. Correct direct invocation.

JavaScript Knowledge References (text-only)

Default export → imported without braces.

Importing default functions gives a callable function, not an object.

Correct syntax: import identifier from " module " .

==================================================

In ES6 class syntax, the special method used to initialize a new instance is called constructor.

A class definition syntax:

class ClassName {

constructor(param1, param2) {

this.prop1 = param1;

this.prop2 = param2;

}

}

The constructor method:

Is called automatically when you create a new instance with new ClassName(...).

Receives the arguments passed in the new expression.

Assigns values to this to set instance properties.

Applying this to Story

We want to be able to write:

const article = new Story( ' Some body ' , ' Author Name ' , 100);

and have:

article.body === ' Some body '

article.author === ' Author Name '

article.viewCount === 100

To achieve this, the class must have:

class Story {

constructor(body, author, viewCount) {

this.body = body;

this.author = author;

this.viewCount = viewCount;

}

}

So the correct line 02 is:

constructor(body, author, viewCount) {

Why the other options are incorrect

A. constructor() {

This defines a constructor with no parameters.

The lines inside the constructor use body, author, and viewCount, which would be undefined unless they exist in an outer scope (they normally do not).

This would lead to the instance properties being set to undefined in normal usage.

B. super(body, author, viewCount) {

super(...) is used inside a constructor of a subclass to call the parent class constructor.

You cannot use super(...) { as a method definition; this is invalid syntax in a class body.

Additionally, Story as given is not shown extending any class, so super is inappropriate here.

C. function Story(body, author, viewCount) {

Inside a class definition, you do not use the function keyword to define methods.

function Story(...) here would be invalid syntax in a class body.

Even if it were allowed, the special constructor method for a class is named constructor, not the class name.

Therefore, only:

constructor(body, author, viewCount) {

correctly declares the constructor for the Story class and ensures instances created with new Story(body, author, viewCount) have all three properties populated.

References / Study Guide concepts (no links):

ES6 class syntax

constructor method in classes

this and instance properties in classes

Difference between class constructors and regular functions

Invalid use of super and function inside class bodies

The correct answer is A .

This object uses a getter :

get fullName() {

return this.firstName + ' ' + this.lastName;

}

A getter looks like a method when it is defined, but it is accessed like a normal property.

So the correct access syntax is:

dog.fullName

That returns:

" Beau Boo "

The important distinction is:

dog.fullName

not:

dog.fullName()

Because fullName is a getter property, not a regular function property.

Option B is incorrect because calling dog.fullName() tries to call the returned string as a function. Since " Beau Boo " is not a function, that would cause a TypeError.

Option C is incorrect because there is no get object inside dog.

Option D is incorrect because there is no function object inside dog, and getters are not accessed that way.

Therefore, the verified answer is A .

The correct answer is B because the JavaScript browser console allows developers to interact with the current web page using JavaScript commands. Through the console, you can access the document object, inspect DOM elements, read their properties, and modify the structure or content of the page.

For example:

document.body.style.backgroundColor = " lightblue " ;

This changes the page’s background color.

Another example:

document.querySelector( " h1 " ).textContent = " Updated Heading " ;

This changes the text of the first < h1 > element on the page.

The DOM , or Document Object Model, is the browser’s JavaScript representation of the HTML page. Since the console runs JavaScript in the context of the current page, it can be used to inspect and modify DOM elements directly.

Why the other options are incorrect:

A is not the best answer because although you can type general JavaScript expressions in the console, the browser console is mainly connected to the current page’s execution environment. The question is asking about practical browser-console actions related to a page.

C is incorrect because performance reports are usually generated through tools such as the Performance panel or Lighthouse in browser developer tools, not directly through the JavaScript console.

D is incorrect because the console can modify the DOM and runtime values, but it does not permanently change the original JavaScript source code of the page. Any changes made through the console are temporary and disappear when the page reloads.

E is incorrect because security-protected cookies, such as HttpOnly cookies, cannot be viewed or changed using JavaScript. This is an intentional browser security feature that prevents client-side scripts from accessing sensitive cookie data.

Therefore, the best verified answer is B .

userInformation is a plain JavaScript object:

{

id: " user-01 " ,

email: " user01@universalcontainers.demo " ,

age: 25

}

You can access object properties in two standard ways:

Dot notation : object.propertyName

Bracket notation : object[ ' propertyName ' ]

Apply to each option:

A. userInformation.email

Correct dot notation; accesses " user01@universalcontainers.demo " .

B. userInformation.get( " email " )

.get() is a method on Map instances, not on plain objects.

A regular object does not have a .get method; this would be TypeError.

C. userInformation[ " email " ]

Correct bracket notation; string " email " is used as the property key.

Returns " user01@universalcontainers.demo " .

D. userInformation[email]

Here email is treated as a variable, not a string literal.

Unless there is a variable named email defined with a value matching a property key, this will either:

Throw a ReferenceError (if email is not defined), or

Use the value of email as a computed key (not what is intended here).

It is not the correct way to access the " email " property literal.

Therefore, the correct ways are:

Answer: A, C

Relevant concepts: object property access (. vs []), plain objects vs Map, literal property names vs computed property names.

In JavaScript, NaN has some special properties:

NaN is not equal to anything, including itself.

Equality operators (==, ===) do not work for detecting NaN.

Check each option:

A. value === Number.NaN

Number.NaN is just NaN.

But NaN === NaN is always false.

So this expression is never true and cannot be used to detect NaN.

B. value == NaN

Same issue. NaN == NaN is always false.

So this also never detects NaN.

C. Object.is(value, NaN)

Object.is is a more precise equality comparison method.

It treats NaN as equal to NaN: Object.is(NaN, NaN) is true.

So Object.is(value, NaN) is a valid way to detect NaN.

D. value !== value

Because NaN is the only JavaScript value that is not equal to itself , value !== value is true only when value is NaN.

This is a classic trick for NaN detection.

E. Number.isNaN(value)

Number.isNaN is the recommended modern way to check if a value is NaN without coercion .

It returns true only if value is actually the number NaN.

Therefore, the three correct ways are:

Object.is(value, NaN)

value !== value

Number.isNaN(value)