50. What is a strict mode in javascript?

In JavaScript, Strict Mode is a way to enforce a stricter set of rules on your code, making it easier to catch common coding mistakes and "unsafe" actions. It helps improve performance and security by preventing the use of certain error-prone features.

How to enable Strict Mode:

You enable strict mode by adding the following directive at the beginning of a script or a function:

javascript
CopyEdit
"use strict";

Example 1: Preventing the use of undeclared variables

Without strict mode:

javascript
CopyEdit
x = 10; // No error (implicitly creates a global variable)
console.log(x); // 10

With strict mode:

javascript
CopyEdit
"use strict";
x = 10; // Error: x is not defined

Example 2: Preventing the use of reserved keywords

Without strict mode:

javascript
CopyEdit
var public = 5; // No error
console.log(public); // 5

With strict mode:

javascript
CopyEdit
"use strict";
var public = 5; // Error: Unexpected strict mode reserved word

Example 3: Catching duplicate parameter names

Without strict mode:

javascript
CopyEdit
function sum(a, a) {
  return a + a;
}
console.log(sum(2, 3)); // Output: 6

With strict mode:

javascript
CopyEdit
"use strict";
function sum(a, a) {
  return a + a; // Error: Duplicate parameter name not allowed in strict mode
}

Why use Strict Mode:

• Prevents accidental global variables.
• Throws errors for assigning values to read-only properties.
• Prevents deletion of non-deletable properties.
• Makes this in functions undefined instead of window (in non-method calls).

Strict mode helps make your code more secure and easier to debug.

You need Strict Mode in JavaScript to improve code quality, prevent common bugs, and enhance security by enforcing stricter parsing and error handling rules. Here’s why strict mode is useful:

1. Prevents accidental global variables

Without strict mode, assigning a value to an undeclared variable creates a global variable, which can lead to unexpected behavior and conflicts.

Without strict mode:

javascript
CopyEdit
x = 5; // Creates a global variable (potential bug)
console.log(x); // 5

With strict mode:

javascript
CopyEdit
"use strict";
x = 5; // Error: x is not defined

2. Prevents the use of reserved keywords

Strict mode prevents the use of future JavaScript reserved words (like public, static, implements) as variable names, which helps ensure compatibility with future language updates.

Example:

javascript
CopyEdit
"use strict";
var public = 10; // Error: Unexpected strict mode reserved word

3. Prevents accidental property assignments

Strict mode throws an error when assigning values to non-writable or non-configurable properties.

Example:

javascript
CopyEdit
"use strict";
var obj = {};
Object.defineProperty(obj, "x", { value: 10, writable: false });

obj.x = 20; // Error: Cannot assign to read-only property 'x'

4. Disallows duplicate parameter names

In non-strict mode, JavaScript allows functions to have duplicate parameter names, which can lead to confusion and bugs.

Example:

javascript
CopyEdit
"use strict";
function test(a, a) { 
    console.log(a);
} // Error: Duplicate parameter name not allowed

5. Makes this undefined in functions

Without strict mode, this defaults to the global object (window in browsers) when used in a function. In strict mode, this remains undefined unless explicitly bound.

Example:

javascript
CopyEdit
"use strict";
function showThis() {
    console.log(this); // undefined
}
showThis();

6. Helps catch silent failures

Some JavaScript operations fail silently without strict mode. Strict mode converts these into visible errors, making them easier to debug.

Example:

javascript
CopyEdit
"use strict";
delete Object.prototype; // Error: Cannot delete property

✅ Benefits of Using Strict Mode:

• Improves code reliability and maintainability.
• Helps catch common mistakes early.
• Enhances security by avoiding potentially dangerous coding patterns.
• Prepares your code for future JavaScript updates.

Strict mode helps write cleaner, more predictable, and less error-prone code.