JavaScript MCQs with answers Page - 2

The correct answer is:

(D) Both 0x and 0X

Explanation:

In most programming languages (such as C, C++, Java, JavaScript, and Python), a hexadecimal literal starts with either 0x or 0X. Both notations are valid and indicate that the number is in hexadecimal (base 16) format.

Examples:

• 0x1A3F (Hexadecimal representation of 6719 in decimal)
• 0XFF (Hexadecimal representation of 255 in decimal)

Thus, the correct answer is (D) Both 0x and 0X.

A real number (floating-point number) in most programming languages follows this general format:

1. [digits] → Represents the integer part (optional).
2. [.digits] → Represents the fractional part (optional).
3. [(E|e)[(+|-)]digits] → Represents the exponent notation (optional).

This allows real numbers to be written in different forms, such as:

• 123.456 (Normal decimal representation)
• 0.789 (Starts with a decimal point)
• 123E4 (Scientific notation, equivalent to 123 × 10⁴)
• 3.14e-2 (Equivalent to 3.14 × 10⁻²)

Thus, option (A) [digits][.digits][(E|e)[(+|-)]digits] correctly represents the general syntax for real number representation.

In JavaScript, when an arithmetic operation results in an infinite value (e.g., division by zero or exceeding the largest representable number), JavaScript does not throw an error. Instead, it represents the result as Infinity or -Infinity, depending on the sign of the operation.

Examples:

console.log(1 / 0);    // Output: Infinity

console.log(-1 / 0);   // Output: -Infinity

console.log(10 ** 1000); // Output: Infinity (Number too large)

console.log(-10 ** 1000); // Output: -Infinity

This behavior ensures that JavaScript handles extreme values gracefully without stopping the execution of the script.

In JavaScript, the enumeration order of object properties is well-defined for own properties but can become implementation-dependent and non-interoperable when inherited properties (i.e., properties from the prototype chain) are enumerable.

• If an object inherits enumerable properties, their enumeration order is not guaranteed to be consistent across different JavaScript engines.
• Different JavaScript engines (like V8, SpiderMonkey, and Chakra) may handle the order of inherited properties differently, leading to inconsistencies in enumeration order.

Thus, option (C) is correct.

var is used to declare variables.

• function is used to declare functions.

Both are declaration statements because they define variables and functions before execution.

Example:

var x = 10;  // Variable declaration

function greet() {  // Function declaration

    console.log("Hello!");

}

Why Not Other Options?

• (A) Prototypes → Incorrect. Prototypes are used in object-oriented JavaScript but var and function are not prototypes.
• (B) Data types → Incorrect. var and function are not data types like string, number, etc.
• (C) Keywords → Partially correct, but they are mainly declaration statements, not just reserved words.

In JavaScript, an empty statement (a semicolon ; with no associated code) is completely ignored by the interpreter. It does not cause an error or warning.

Example:

;;;

console.log("Hello, World!");

• The semicolons (;;;) are empty statements, but they are ignored.
• The code runs without any issues and prints "Hello, World!".

Why Not Other Options?

• (A) Throws an error → Incorrect. JavaScript does not throw an error for empty statements.
• (B) Shows a warning → Incorrect. No warnings are generated for empty statements.
• (D) Prompts to complete the statement → Incorrect. JavaScript does not prompt the user for incomplete code; it simply ignores empty statements.

A block statement (or compound statement) in JavaScript is used to group multiple statements together within curly braces {}. It is typically used in control structures like if, for, while, and function definitions.

Example of a Block Statement:

{

    let a = 10;

    let b = 20;

    console.log(a + b); // 30

}

• The {} braces group the let declarations and console.log() into a single block.
• The block does not affect execution unless used in a specific context (like inside an if or loop).

Why Not Other Options?

• (B) Both conditional block and single statement → Incorrect. A block statement can contain multiple statements, not just a single statement.
• (C) Block that contains a single statement → Incorrect. A block is meant to group multiple statements, although it can contain just one.
• (D) Conditional block → Incorrect. A block can be used inside conditionals, but it is not limited to them.

A conditional expression in JavaScript refers to the ternary operator (? :), which is also known as the "immediate if" because it provides a quick, one-line alternative to an if-else statement.

Syntax of Ternary Operator:

condition ? expression1 : expression2;

• If condition is true, expression1 executes.
• If condition is false, expression2 executes.

Example:

let age = 18;

let canVote = (age >= 18) ? "Yes" : "No";

console.log(canVote); // Output: "Yes"

Why Not Other Options?

• (A) If-then-else statement → Incorrect. The ternary operator is not a full if-else statement but a single expression.
• (B) Alternative to if-else → Partially correct, but the ternary operator is a shortened version of if-else, not an exact alternative in all cases.
• (D) All of the above → Incorrect. Since A and B are not fully correct, this option is also incorrect.

JavaScript is Object-Based rather than fully Object-Oriented because:

Object-Based Language

• JavaScript uses objects extensively but does not support features like class-based inheritance (before ES6 introduced class syntax).
• It follows prototype-based inheritance rather than classical OOP (Object-Oriented Programming).

Why Not Other Options?

• (B) Assembly-language → ❌ Incorrect, because JavaScript is a high-level language, not low-level like Assembly.
• (C) High-level → ✅ JavaScript is a high-level language, but the most precise classification is "Object-Based."
• (D) Object-Oriented → ❌ JavaScript does have OOP features (like objects and prototypes), but it lacks true class-based OOP principles like Java or C++.

Thus, JavaScript is primarily "Object-Based" because it uses objects but not full OOP features.

In JavaScript, we can convert a boolean (false) to a string in two ways:

Using .toString() method

• The .toString() method converts false to the string "false".
• It works only if false is a primitive value, not null or undefined.

Using String() function

• The String() function also converts false to a string.
• It works with any value (null, undefined, numbers, booleans, etc.).

Why Not Other Options?

• (A) String newvariable=”false” → ❌ Incorrect, because this is not valid JavaScript syntax.
• (C) String(false) → ✅ Correct, but not the only correct answer.
• (D) false.toString() → ✅ Correct, but not the only correct answer.

Since both methods work, the best answer is (B) Both false.toString() and String(false).

var str2 = String(false);

console.log(str2);  // Output: "false"

var str1 = false.toString();

console.log(str1);  // Output: "false"