JavaScript MCQs with answers Page - 3

In JavaScript, the === (strict equality operator) checks both:

1. Value equality (i.e., p and q must have the same value)
2. Type equality (i.e., p and q must be of the same data type)

Example 1: Equal in Value and Type (true output)

var p = 10;

var q = 10;

console.log(p === q);  // Output: true (same value and same type)

Example 2: Same Value, Different Type (false output)

var p = 10;       // Number

var q = "10";     // String

console.log(p === q);  // Output: false (different types: number vs string)

Why Not Other Options?

• (A) "There is no such statement" → ❌ Incorrect, because p === q is a valid JavaScript statement.
• (B) "Both p and q are equal in value, type, and reference address" → ❌ Incorrect, because === does not compare reference addresses. It only checks value and type.
• (C) "Both p and q are equal in value" → ❌ Incorrect, because === checks both value and type, not just value.

Final Answer:

✅ (D) Both p and q are equal in value and type.

In JavaScript, we use !== (strict inequality operator) to check both:

1. Value inequality
2. Type inequality

Example: Checking if a is not null

var a = "Hello";  // Example value

if (a !== null) {

    console.log("a is not null");

} else {

    console.log("a is null");

}

Output:

a is not null

If a = null, then the condition fails.

Why Not Other Options?

• (B) if(a!null) → ❌ Incorrect (invalid syntax; ! should be used with boolean expressions, not values).
• (C) if(!a) → ❌ Incorrect (this checks if a is falsy, but 0, "", undefined, NaN, and false are also falsy, not just null).
• (D) if(a != null) → ✅ Correct, but (A) is preferred because != does type coercion, whereas !== strictly checks for null.

Final Answer:

✅ (A) if(a !== null) (Best practice for checking null).

In JavaScript, the escape sequence f stands for Form Feed. It is a control character used in old printers to signal a page break. However, in modern JavaScript applications, it is rarely used and often ignored by modern browsers and text processors.

Example in JavaScript:

console.log("HellofWorld");

Output (may vary depending on the console):

HelloWorld

(The f may not be visible in many text editors.)

Why Not Other Options?

• (B) f is not present in JavaScript → ❌ Incorrect (It does exist in JavaScript).
• (C) Representation of functions that return a value → ❌ Incorrect (f is not related to functions).
• (D) Floating numbers → ❌ Incorrect (f has nothing to do with floating-point numbers).

Final Answer:

✅ (A) Form feed

In JavaScript, dividing a number by zero does not throw an error. Instead, it returns Infinity (or -Infinity for negative numbers). JavaScript handles division by zero gracefully, unlike some other languages where it may cause an error.

Example:

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

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

However, if the value is 0/0, it results in NaN (Not-a-Number):

console.log(0 / 0); // Output: NaN

Why Not Other Options?

• (A) Missing of Bracket → ❌ Error (Missing brackets can cause syntax errors).
• (B) Syntax error → ❌ Error (Incorrect syntax results in a SyntaxError).
• (C) Missing of semicolons → ❌ Error (Although JavaScript has automatic semicolon insertion, in some cases, missing semicolons can lead to unexpected behavior or errors).

Final Answer:

✅ (D) Division by zero (It returns Infinity instead of throwing an error).

In JavaScript, when an arithmetic computation results in an indefinite or infinite value, JavaScript does not throw an error. Instead, it returns Infinity (or -Infinity for negative values).

Example:

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

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

If the result of a computation is undefined (like 0/0), JavaScript returns NaN (Not-a-Number):

console.log(0 / 0); // Output: NaN

Why Not Other Options?

• (A) Prints the value as such → ❌ Incorrect (JavaScript does not print raw values; instead, it handles them specifically as Infinity).
• (B) Prints an exception error → ❌ Incorrect (JavaScript does not throw an exception for division by zero).
• (C) Prints an overflow error → ❌ Incorrect (JavaScript does not have an "overflow error" like some other languages).

Final Answer:

✅ (D) Displays “Infinity”

In JavaScript, code can be executed in multiple ways, but the most common and structured way is through functions or methods. A function is a reusable block of code that performs a specific task when called.

Example of Calling JavaScript Code Using a Function:

function greet() {

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

}

greet();  // Calling the function

Why Not Other Options?

(A) Preprocessor → ❌ Incorrect
JavaScript is an interpreted language, meaning it does not require preprocessing like languages such as C or C++.

(C) RMI (Remote Method Invocation) → ❌ Incorrect
RMI is a Java-based technology used for remote procedure calls, not for JavaScript execution.

(D) Triggering Event → ❌ Partially Correct
Events like onClick, onLoad, etc., can execute JavaScript, but they usually call functions to perform the actual logic.

Final Answer:

✅ (B) Function/Method

The ?: operator is known as the ternary operator, and it is a shorthand for an if-else statement. It takes three operands:

condition ? expression_if_true : expression_if_false;

For example:

let result = (x > 10) ? "Greater" : "Smaller";

This means that if x > 10 is true, result will be "Greater", otherwise, it will be "Smaller".

The in operator is used to test if a property exists in an object or in an array. For example:

let obj = { name: "John", age: 30 };



console.log("name" in obj); // true

console.log("address" in obj); // false

This checks if the property (e.g., "name") is present in the object (obj).

The expression new Point(2, 3) is an example of an object creation expression. It uses the new keyword to create an instance of the Point class (or constructor function), initializing it with the arguments 2 and 3. This is typically used to instantiate new objects in object-oriented programming.