JS-Dev-101 Exam Dumps and Practice Questions

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)

Option A:

this.growl = () => { ... } inside the constructor creates a new function per instance.

For 1000 new Monster(), you get 1000 distinct growl functions, each stored on the instance itself.

Option B:

Monster.prototype.growl = () => { ... } attaches growl to the prototype.

All instances share the same single growl function via the prototype chain.

For 1000 instances, only 1 growl method exists in memory.

So: Option A 1000; Option B 1.

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.

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:

Answe r: D

Study Guide / Concept Reference (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

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.