To select an element by ID, JavaScript uses:
document.getElementById( " status " )
The ID must be passed without any selector prefixes (no dot, no hash).
Then, to update the text inside:
element.innerHTML = ' Completed ' ;
Why the others are wrong:
* A uses " .status " which would match a CSS class, not an ID.
* B incorrectly prepends #, which is used in CSS selectors but not in getElementById.
* D attempts to use .Value with capital V, which is incorrect for DOM text; .value only applies to form elements.
Thus, option C is correct.
JavaScript Knowledge References (text-only)
* getElementById takes a raw ID string with no prefixes.
* innerHTML updates an element's displayed HTML content.

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.

New behavior: sum3 now returns the sum of all elements .
* Line 01: sum3([1, 2, 3]) # 1 + 2 + 3 = 6
* Assertion on line 02: res === 6 # passes.
* Line 04: sum3([1, 2, 3, 4]) # 1 + 2 + 3 + 4 = 10
* Assertion on line 05: res === 6 # 10 === 6 is false, so the assertion fails.
So:
* Line 02 assertion passes # D.
* Line 05 assertion fails # C.

The answer is B because JavaScript uses lexical scope .
When a function is created inside another function, the inner function can access variables from the outer function where it was defined.
For example:
function first() {
let a = 10;
function second() {
console.log(a);
}
second();
}
Here, a belongs to the outer function first(). The inner function second() can access it because JavaScript looks for variables through the scope chain.
The lookup works like this:
1. Look inside second()
2. If not found, look inside first()
3. If not found, look in the global scope
Since a is found in the outer function's scope, second() can use it.
This is also the basis of a closure . A closure allows an inner function to remember and access variables from its outer lexical environment.
Why the other options are incorrect:
A is not the best answer because a is not declared inside second() itself.
C is incorrect because the prototype chain is used for object property lookup, not local variable scope lookup.
D is incorrect because hoisting explains how declarations are moved during compilation, but it does not explain why an inner function can access an outer function's variable.
Therefore, the verified answer is B .

Recall:
* NaN stands for "Not-a-Number".
* Arithmetic involving non-numeric values that cannot be converted to numbers often results in NaN.
Check each:
* A. 10 / 0
* In JavaScript, dividing a positive number by 0 results in Infinity, not NaN.
* So this logs Infinity.
* B. parseInt( ' two ' )
* parseInt tries to parse a numeric prefix from the string.
* ' two ' does not start with numeric digits, so parseInt( ' two ' ) returns NaN.
* The console log prints NaN.
* C. 10 / Number( ' 5 ' )
* Number( ' 5 ' ) # 5.
* 10 / 5 # 2.
* Logs 2, not NaN.
* D. 10 / ' five '
* ' five ' is coerced to a number using Number( ' five ' ), which is NaN.
* 10 / NaN # NaN.
* Logs NaN.
So the console logs that output NaN are from B and D.
Relevant concepts: NaN, Infinity, parseInt, Number() coercion, arithmetic with invalid numeric values.