The correct answers are C and D .

The statement:

const arr = Array(5).fill(0);

creates an array with 5 elements , and every element is filled with the value 0.

So the array becomes:

[0, 0, 0, 0, 0]

A professional test should verify both important expectations:

arr.length === 5

and:

each element === 0

Option C is correct because it checks every element in the array:

arr.forEach(e = > console.assert(e === 0));

This confirms that each array element was filled with 0.

Option D is correct because it checks the array length:

console.assert(arr.length === 5);

This confirms that the array contains exactly five elements.

Option A is incorrect because the array length is not 0; it is 5.

Option B is incorrect for two reasons. First, arr[5] is outside the valid index range. The valid indexes are:

0, 1, 2, 3, 4

So:

arr[5]

returns:

undefined

Second, arr.length === 0 is false because the length is 5.

Therefore, the verified answers are C and D .

There are two valid ways to ensure leo.roar() exists:

Directly assign a roar function to leo (Option A). Assigning a property to an instance object creates a new method on that instance.

leo.roar = () = > { console.log( ' They\ ' re pretty good! ' ); };

After this, calling leo.roar() is valid.

Copy tony’s properties into leo using Object.assign (Option B). Object.assign(target, source) copies enumerable own properties from the source object into the target object. Since tony.roar exists, executing:

Object.assign(leo, tony);

copies roar into leo, making leo.roar() valid.

Why the other answers are incorrect:

Option C: Object.assign(leo, Tiger) copies properties from the function object Tiger , not from Tiger.prototype and not from a Tiger instance. Tiger (the function) has no roar property, so nothing useful is copied.

Option D: leo.prototype is undefined because leo is an instance, not a constructor function. Only constructor functions have a .prototype property. This line would cause an error.

JavaScript Knowledge References (text-only)

Instances have their own properties and do not contain a .prototype property.

Object.assign(target, source) copies own enumerable properties of the source object.

Assigning a function as a property of an object creates a callable method.

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

We start with the array:

let inArray = [ [1, 2], [3, 4, 5] ];

This is an array of two inner arrays:

First element: [1, 2]

Second element: [3, 4, 5]

The desired result is to transform this into a single, flat array:

[1, 2, 3, 4, 5]

This is accomplished by using Array.prototype.concat to concatenate the inner arrays into one new array, optionally combined with the spread syntax (...) or Function.prototype.apply.

Option A: [].concat(...inArray);

Relevant concepts:

Spread syntax (...inArray) expands an iterable into separate arguments.

Array.prototype.concat joins arrays or values into a new array. When you pass arrays as arguments to concat, it flattens them one level into the result.

Step-by-step behavior:

inArray is [ [1, 2], [3, 4, 5] ].

...inArray expands into [1, 2] and [3, 4, 5] as separate arguments.

So [].concat(...inArray) is equivalent to:

[].concat([1, 2] , [3, 4, 5]);

concat processes each argument:

For [1, 2], it adds 1 and 2 into the result array.

For [3, 4, 5], it adds 3, 4, and 5 into the result array.

The final outcome is:

[1, 2, 3, 4, 5]

Therefore, Option A correctly produces the desired array.

Option B: [].concat.apply(inArray, [] );

Corrected name from usArray to inArray.

Relevant concepts:

Function.prototype.apply(fnThis, argsArray) invokes a function with a specific this value and a list of arguments passed as an array.

Here:

thisArg is inArray.

argsArray is [] (no actual arguments passed).

So the call:

[].concat.apply(inArray, [] );

is equivalent to:

Array.prototype.concat.apply(inArray, []);

// i.e. inArray.concat();

Since there are no extra arguments, inArray.concat() simply returns a shallow copy of inArray:

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

This remains an array of arrays and is not flattened into [1, 2, 3, 4, 5]. Therefore, Option B does not produce the required result.

Option C: [].concat::...inArray();

Corrected name from usArray to inArray and .. to ....

This expression uses syntax that is not part of standard JavaScript:

:: (double colon) was proposed in early drafts as a bind operator but is not part of the official ECMAScript standard.

The combination concat::...inArray() is invalid in normal JavaScript engines and cannot be used as a valid way to flatten arrays.

In addition, inArray() would imply calling inArray as a function, but it is an array, which would cause a runtime error.

Hence, Option C is syntactically or semantically invalid in standard JavaScript and does not provide the required result [1, 2, 3, 4, 5].

Option D: [].concat.apply({}, inArray);

Corrected name from usArray to inArray.

Relevant concepts:

Again, Function.prototype.apply is used to call concat with a specific this value and arguments provided as an array.

concat treats its this value as an array-like object but ultimately returns a new array containing concatenated elements.

In this expression:

[].concat.apply({}, inArray);

thisArg is {} (an empty object).

argsArray is inArray, which is [ [1, 2], [3, 4, 5] ].

Using apply, this is interpreted as calling concat like:

Array.prototype.concat.call({}, [1, 2], [3, 4, 5] );

concat then:

Starts from the array-like this (here {} is treated as an empty base).

Takes the first argument [1, 2] and appends its elements 1 and 2 to the result.

Takes the second argument [3, 4, 5] and appends its elements 3, 4, and 5 to the result.

The resulting new array is:

[1, 2, 3, 4, 5]

Therefore, Option D also correctly produces the required array.

Final evaluation of all options:

Option A: Uses spread syntax with concat and correctly flattens one level: [1, 2, 3, 4, 5].

Option B: Equivalent to inArray.concat(), leaving it as [[1, 2], [3, 4, 5]] . Does not flatten the structure.

Option C: Uses non-standard and invalid syntax; not a valid or correct JavaScript solution.

Option D: Uses apply with concat, passing the inner arrays as arguments and flattening one level to [1, 2, 3, 4, 5].

Thus, the two correct statements are:

Answer: A, D

References of JavaScript knowledge documents or Study Guide (concept names only):

Array.prototype.concat (concatenating and one-level flattening behavior)

Spread syntax for arrays (...array)

Function.prototype.apply (calling a function with a given this value and arguments list)

Array flattening by one level using concat with array arguments

Distinction between nested arrays and flat arrays in JavaScript

We want to convert the number 1982 to a string.

Check each option:

A. numValue.toText()

There is no standard toText() method on numbers.

This will result in TypeError: numValue.toText is not a function.

B. String(numValue);

String() as a function converts its argument to a string.

String(1982) returns " 1982 " .

This is correct.

C. ' ' + numValue;

' ' is a string; + with a string operand performs string concatenation.

' ' + 1982 → " 1982 " .

This is a common shorthand for number-to-string conversion.

D. numValue.toString();

Number.prototype.toString() converts the number to its string representation.

1982..toString() or (1982).toString() returns " 1982 " .

For the variable, numValue.toString() is valid: " 1982 " .

E. (String)numValue;

This is not valid JavaScript casting syntax; it is more like a C/Java-style cast.

In JavaScript, that is parsed as a grouping expression (String) and then numValue; it does not convert numValue to a string.

Thus the correct answers are:

B. String(numValue);

C. ' ' + numValue;

D. numValue.toString();

Relevant concepts: primitive type conversion, String() casting, .toString(), coercion via + with strings.

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.

We want:

const addByEight = addBy(8);

const sum = addByEight(50);

And we need sum to be 58.

That means:

addBy(8) must return a function.

That returned function, when called with 50, must compute 8 + 50.

So addBy must be a higher-order function that returns another function capturing num1 and later using it with num2 (a closure).

Option A

const addBy = function(num1) {

return function(num2) {

return num1 + num2;

}

}

Step-by-step:

Call addBy(8):

num1 is 8.

The function returns an inner function: function(num2) { return num1 + num2; }.

So addByEight becomes this inner function, with num1 closed over as 8.

Then call addByEight(50):

num2 is 50.

The body computes num1 + num2, i.e., 8 + 50 = 58.

Therefore, with Option A in place:

const addByEight = addBy(8); // returns inner function

const sum = addByEight(50); // 58

So sum is 58. Option A is correct.

Option D (corrected)

const addBy = (num1) = > {

return function(num2) {

return num1 + num2;

}

}

This is essentially the same logic expressed with an arrow function for the outer function:

Call addBy(8):

num1 is 8.

Returns the inner function function(num2) { return num1 + num2; }.

Call addByEight(50):

num2 is 50.

Computes num1 + num2 → 8 + 50 = 58.

So again:

const addByEight = addBy(8); // inner function with num1 = 8

const sum = addByEight(50); // 58

Option D is also correct.

Thus, A and D are the two functions that satisfy the requirement.

Why B and C are incorrect

Option B:

const addBy = function(num1) {

return num1 * num2;

}

This does not return a function; it returns a value.

addBy(8) returns 8 * num2, but num2 is not defined in this scope, which would cause a ReferenceError.

Also, addByEight would be a number (if num2 existed), not a function, so addByEight(50) would fail.

Option C:

const addBy = (num1) = > num1 + num2;

Again, addBy returns a value, not a function.

addBy(8) returns 8 + num2, but num2 is not defined, so this is also invalid due to ReferenceError.

addByEight would be a number (or error), not a function.

Neither B nor C creates the required closure nor returns a function to be called later.

References / Study Guide concepts (no links):

Higher-order functions in JavaScript

Closures: inner functions capturing outer variables (num1)

Arrow functions vs function expressions

Returning functions from functions (function factories / currying)

Scope and ReferenceError when a variable is not defined

React and Vue are:

Mature front-end JavaScript frameworks/libraries.

Have large communities.

Are widely supported and used in production across industries.

Appropriate for building browser-based Single Page Applications.

Express and Koa are server-side frameworks , not front-end SPA frameworks.

The scenario describes building a browser SPA, so the correct seasoned options are React and Vue.

JavaScript Knowledge References (text-only)

React and Vue are client-side frameworks for SPA development.

Express and Koa are backend frameworks for Node.js.

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

Browsers often cache JavaScript, CSS, and HTML. This means:

The developer may be running with the latest version (often with cache disabled in DevTools).

The tester may still be loading an older, cached version of the page where the background-change logic does not exist.

To ensure they are actually testing the latest deployed code:

Disabling cache (A) in the tester’s browser (usually via DevTools → Network → “Disable cache”) forces fresh loading of all resources on each refresh.

Clearing cache (C) removes older resources from the browser so the next load fetches fresh files from the server.

Options B and D do not directly help verify the tester is using the latest code:

B checks the developer’s own browser, which is not the environment showing the problem.

D suggests reworking the code before confirming whether the tester is actually loading the correct version, which is premature.

So the two actions that help produce accurate testing results are A and C.

Facts about JavaScript Promises:

runParallel() is declared async, which means it always returns a Promise .

Promises are consumed using .then(), .catch(), and .finally().

There is no .done() method in native JavaScript Promises.

The async keyword cannot be placed before a function call (option A is invalid syntax).

Analysis of each option:

A. async runParallel().then(data);

Invalid syntax. async cannot prefix an expression.

B. Valid. Calls the function and attaches a .then() handler.

C. Invalid. .done() is not part of JavaScript Promise API.

D. Valid. Calls runParallel() and chains .then().

Therefore the correct answers are B and D.

JavaScript Knowledge References (text-only)

async functions return Promises.

Promises use .then() to retrieve resolved values.

.done() is not part of the standard Promise interface.

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

The correct answers are B, C, D, and E .

JavaScript browser consoles support string substitution in several console output methods. String substitution means using placeholders such as:

%s

%d

%i

%f

%o

%O

%c

Example:

console.log( " User name is %s and age is %d " , " Alex " , 25);

Output:

User name is Alex and age is 25

The valid console methods from the given options are:

Option

Method

Correct?

Reason

A

message

No

console.message() is not a standard console method.

B

log

Yes

console.log() supports formatted string substitution.

C

assert

Yes

console.assert() can output a formatted message when the assertion is false.

D

info

Yes

console.info() supports formatted output like console.log().

E

error

Yes

console.error() supports formatted output and displays an error-style message.

Example with these valid methods:

console.log( " Name: %s " , " John " );

console.info( " Score: %d " , 95);

console.error( " Error code: %d " , 500);

console.assert(false, " Failed check for user: %s " , " Admin " );

So the verified answers are B, C, D, and E .

The correct answers are A, B, and D .

The two variables are:

let str1 = ' Java ' ;

let str2 = ' Script ' ;

The goal is to combine them into:

JavaScript

Option A is correct because template literals can insert variables directly into a string:

`${str1}${str2}`

This becomes:

`${ ' Java ' }${ ' Script ' }`

Result:

JavaScript

Option B is correct because strings have a concat() method:

str1.concat(str2);

This joins str2 onto the end of str1.

Result:

JavaScript

Option D is correct because the + operator performs string concatenation when both operands are strings:

str1 + str2;

This becomes:

' Java ' + ' Script '

Result:

JavaScript

The incorrect options:

Option C is not valid JavaScript for joining strings. const is used for declaring constants, not concatenating values.

Option E is incorrect because join() is an array method, not a string method. This would only work with an array, for example:

[ ' Java ' , ' Script ' ].join( ' ' );

But str1 is a string, so:

str1.join(str2)

is invalid.

Therefore, the verified answers are A, B, and D .

We already know NaN is special: it is not equal to itself.

Check each:

A. value === Number.NaN

Number.NaN is NaN.

NaN === NaN is always false.

This will never be true; cannot reliably detect NaN.

B. value == NaN

NaN == NaN is also always false.

Again, this never detects NaN.

C. isNaN(value)

Global isNaN converts its argument to a number and then checks if the result is NaN.

This can detect NaN, but it may also return true for non-number values that coerce to NaN, such as isNaN( ' foo ' ).

Regardless, it is a standard way to detect if a value is “NaN-like” in JavaScript.

D. Object.is(value, NaN)

Object.is(NaN, NaN) returns true.

This is a strict way to detect a value that is exactly NaN (no coercion).

Therefore, among the given choices, the two viable ways to detect NaN are:

isNaN(value)

Object.is(value, NaN)