One question at a time. Build your JSE Certified Entry-Level JavaScript Programmer understanding.
First 50 of 199 questions. Each one lists the choices, the correct answer, and an explanation. The checker at the top of this page saves progress in this browser when it is available.
Continue in the practice tool above to load more questions, 50 at a time.
The const declaration creates a binding that is block-scoped and must be initialized at declaration time, and reassigning it throws a TypeError. The binding itself is immutable, though objects it references can still be mutated.
typeof null returns the string "object" because of a long-standing historical quirk in the language's original implementation. This is not a reliable null check; comparing with === null is the correct approach.
The postfix increment operator returns the value before incrementing. So the expression evaluates to 10 while x becomes 11 afterward. Using ++x would return 11 instead.
The strict equality operator === compares both type and value and returns false when the operands differ in type. The loose equality operator == coerces operands before comparing.
When either operand of + is a string, the operator performs string concatenation rather than numeric addition. The number 3 is converted to the string "3" and appended, giving "53".
Array.prototype.push appends its arguments to the end of the array and returns the updated length. This differs from pop, which removes from the end and returns the removed element.
A function with no executed return statement implicitly returns undefined. This is distinct from returning no value explicitly, which also yields undefined.
let declarations are scoped to the nearest enclosing block, such as a loop body or an if block. The binding is also hoisted but stays in a temporal dead zone until the declaration is evaluated.
Loose equality coerces the boolean false to the number 0 before comparing, so 0 == false is true. Using strict equality, 0 === false, would evaluate to false because the types differ.
The number 0 is one of the falsy values, along with "", null, undefined, NaN, and false. Empty arrays and empty objects are truthy because objects are always truthy.
A var declaration in a for loop is function-scoped, so i remains accessible after the loop. The loop stops when i reaches 3, which is the value printed.
The strict equality operator === compares value and type, so name === "admin" is true only when name is exactly that string. It avoids the coercion surprises of loose equality.
The remainder operator % returns what is left after dividing the left operand by the right one. Since 10 divided by 3 leaves a remainder of 1, the result is 1.
switch compares the discriminant against each case using strict equality, so values must match in type and value. Without break, execution falls through to subsequent cases.
The inner let a inside the block creates a separate binding shadowing the outer one. When the block ends, the outer a is still 1, which is what console.log prints.
An arrow function may omit parentheses for a single parameter and use an expression body whose value is returned implicitly. So x => x * x returns the square of x without a return keyword.
The inner typeof 42 evaluates to the string "number". Applying typeof again to that string yields "string", because the operand is now a string value.
filter builds and returns a new array whose elements all pass the predicate function. The original array is not modified by filter.
The length property of an array reports the number of elements it contains. An array literal with three elements therefore has length 3.
Binary floating-point cannot represent 0.1 and 0.2 exactly, so their sum is slightly greater than 0.3. The strict comparison therefore evaluates to false.
The loop increments i while it is below 3, exiting when i reaches 3. Because the increment happens before the condition is rechecked, the final logged value is 3.
When a method is called as obj.get(), this refers to obj, so this.n resolves to 1. The result changes if the function is detached and called without a receiver.
The logical AND operator returns the first falsy operand or the last operand if all are truthy. Since true is truthy, evaluation proceeds and returns "hello".
Addition evaluates left to right, so 1 + 2 first yields the number 3. Then 3 + "3" triggers string concatenation because the right operand is a string, producing "33".
A named function expression binds its name inside its own scope, so g is accessible within the body. The typeof operator therefore reports "function", even though g is not visible outside.
JavaScript assigns multiplication a higher precedence level than addition, so the grouping is a + (b * c) rather than (a + b) * c. This means the product is computed first and its result is then added to a. Parentheses can always override this default grouping when a different order is needed.
An identifier must start with a letter, dollar sign, or underscore, and subsequent characters may also include digits. Starting with a digit is never allowed because such tokens would be parsed as numeric literals. Hyphens are reserved for subtraction, so they cannot appear inside a single identifier.
The inner function closes over the scope in which it was defined, which is the body of outer where a local x equals 10. Lexical scoping resolves the name to the nearest enclosing binding, so the outer const x = 5 is not consulted. The returned value is therefore 10.
The typeof operator reports "object" for null, a long-standing quirk retained for backward compatibility since the earliest implementations. To test for null reliably, compare directly with the null value using strict equality. The result does not indicate that null is a usable object.
The map callback receives the element value and its index, so each element is incremented by its position: 10+0, 20+1, and 30+2. The method returns a new array of those results, and join converts it to the comma-separated string 10,21,32. The original array is left unchanged.
Since the earliest implementations, `typeof null` evaluates to the string "object" because of how the type tag for null was encoded. This is a long-standing quirk that is preserved for backward compatibility. It does not mean null is an object; it is a distinct primitive value.
Numbers are IEEE 754 double-precision floats, so 0.1 and 0.2 cannot be stored exactly. Their sum is slightly greater than 0.3, so the strict comparison yields false. This is a floating-point representation issue, not a JavaScript bug.
`let` declarations are hoisted to the top of their block but are not initialized, so accessing them before the declaration throws a ReferenceError. This uninitialized period is called the temporal dead zone. By contrast, `var` is hoisted and initialized to undefined.
The `+` operator performs string concatenation when either operand is a string, so the number 3 is converted to "3" and joined to "5". The result is the string "53", not a numeric sum. Numeric addition only occurs when both operands are numbers after conversion.
Both arrays are converted to primitives, and an array's default string conversion is its joined elements. Two empty arrays each become the empty string, and string concatenation yields the empty string. The `+` operator sees strings and concatenates rather than adding.
NaN represents an invalid numeric result and is defined to be unequal to every value, including itself. That is why `Number.isNaN` or `Object.is` is used to detect it. The other listed values are strictly equal to themselves.
The `typeof` operator returns the string "undefined" for the undefined value as well as for variables that have been declared but not assigned. This distinguishes it from null, which returns "object". There is no "void" type name in the typeof result set.
`const` creates a binding that is block-scoped and must be initialized at declaration, and reassigning it throws a TypeError. `let` is block-scoped but reassignable, and `var` is function-scoped. `static` is not a variable declaration keyword at the top level.
The Number function converts its argument strictly: the whole string must be a valid numeric literal, otherwise the result is NaN. Because "12px" contains trailing letters, conversion fails and NaN is returned. `parseInt` would instead parse the leading digits and return 12.
When converting to boolean, only a specific set of values are falsy: false, 0, -0, 0n, "", null, undefined, and NaN. Any non-empty string, including "0", is truthy. Therefore Boolean("0") returns true.
The bigint zero literal 0n is one of the falsy values, along with false, 0, -0, "", null, undefined, and NaN. Non-empty strings, arrays, and objects are all truthy regardless of their contents. This is why an empty array is truthy.
The abstract equality algorithm contains a special rule: null and undefined are loosely equal to each other and to nothing else. No numeric coercion happens in this comparison. With strict equality, `null === undefined` is false because their types differ.
With loose equality between a string and a number, the string is converted to a number first. The empty string converts to 0, so the comparison becomes 0 == 0, which is true. Strict equality `"" === 0` would be false because the types differ.
Adding a string forces the array to be converted to a primitive, and Array.prototype.toString joins the elements with commas. The result is the string "1,2,3". The elements are not summed, because the `+` operator concatenates once a string operand is present.
The `typeof` operator returns a string such as "number", "string", "boolean", "object", "function", or "undefined". `instanceof` instead tests whether an object's prototype chain includes a given constructor's prototype. The other options are object methods, not type-returning operators.
The `+` operator converts undefined to a number, which yields NaN, and any arithmetic on NaN produces NaN. Because there is no string operand, concatenation does not occur. The result is therefore NaN.
The `typeof` operator returns the special string "function" for callable objects, even though functions are technically objects. This is a deliberate exception so that functions can be distinguished from ordinary objects. There is no "callable" result from typeof.
The `+` operator is left-associative and evaluated left to right. First 2 + 3 performs numeric addition to give 5, then 5 + "4" concatenates to produce the string "54". The position of the string operand changes the outcome.
NaN is defined as unequal to every value, including itself, so `NaN === NaN` is false. This is why `Number.isNaN` exists to test for NaN reliably. The comparison operator returns a boolean, not NaN.
BigInt values are a distinct primitive type, and `typeof` reports them as "bigint". They are not the same type as regular numbers, even though they represent integers. Mixing a bigint and a number in arithmetic without explicit conversion throws a TypeError.