JavaScript MCQs with answers Page - 2

Explanation:

A volatile variable refers to a variable whose value can change unexpectedly due to external factors such as hardware changes, multi-threading, or signal handlers. Such variables are typically mutable, meaning they can be modified during program execution.

Other options:

• (A) Volatile variable → While "volatile" is a keyword in some languages like C and Java, it does not define a variable type; rather, it is a qualifier.
• (C) Immutable variable → Incorrect, as immutable variables cannot change once assigned.
• (D) Dynamic variable → This usually refers to variables that are allocated dynamically in memory but does not specifically relate to volatility.

Thus, the correct answer is (B) Mutable variable.

Explanation:

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.

Explanation:

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.

Explanation:

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.

Explanation:

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.

Explanation:

Let's analyze the JavaScript code snippet:

var num = 1;

while (num < 15) 

{

     console.log(num);

     num++;

}

• The while loop starts with num = 1.
• The condition num < 15 is true initially.
• Inside the loop, console.log(num) prints the current value of num.
• Then, num++ increments num by 1 after each iteration.
• The loop continues until num reaches 15, at which point the condition num < 15 becomes false, and the loop stops.
• Therefore, the numbers from 1 to 14 will be printed in the console.

Thus, option (D) is correct.

Explanation:

Actually, the correct answer depends on the JavaScript version.

• In modern JavaScript (ES6 and later), the switch statement uses strict equality (===) for comparison.
• In older JavaScript versions (before ES6), it used loose equality (==), allowing type coercion.

Final Answer:

✅ (A) === (for modern JavaScript)

Example (Modern JavaScript - === used)

let num = "5";



switch (num) {

    case 5:

        console.log("Matched with 5");

        break;

    case "5":

        console.log("Matched with '5'");

        break;

    default:

        console.log("No match");

}

Output:

Matched with '5'

✅ Here, only the exact type match ("5" with "5") works, proving that === is used in modern JS.

Explanation:

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.

Explanation:

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.

Explanation:

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.