JavaScript Use Strict

The "use strict"; directive in JavaScript enforces a stricter parsing and error-handling mode. This directive, which you place at the top of a file or function, helps avoid some common mistakes and provides a safer environment for executing JavaScript code.

Here’s a breakdown of how "use strict"; affects JavaScript code:

1. How to Enable Strict Mode

• At the beginning of a JavaScript file:

"use strict";
// Whole script is in strict mode

Inside a function:

function myFunction() {
  "use strict";
  // This function is in strict mode
}

2. Key Features of Strict Mode

• Prevents Undeclared Variables: Variables must be declared with var, let, or const. Otherwise, an error is thrown.

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

Eliminates this Binding for Functions: In regular mode, this can be globally bound, but in strict mode, this will be undefined if not explicitly set.

"use strict";
function myFunction() {
  console.log(this); // undefined
}

Disallows Duplicates in Object Properties or Function Parameters:

"use strict";
const obj = { prop: 1, prop: 2 }; // Error: Duplicate property

Throws Errors for Writing to Read-Only Properties: Prevents accidentally changing read-only or non-writable properties.

"use strict";
const obj = Object.freeze({ prop: 1 });
obj.prop = 2; // Error

• Prohibits Use of Reserved Keywords for Future JavaScript: Certain words like public, static, implements, etc., are disallowed.

3. Benefits of Using Strict Mode

• Improves Error Detection: Catches common coding mistakes early.
• Increases Security: Prevents unsafe actions, which helps avoid potential security issues.
• Optimizes Performance: Many JavaScript engines optimize strict mode code, making it potentially faster.

Example of Strict Mode in Use

"use strict";
function calculateArea(radius) {
  if (radius <= 0) throw new Error("Radius must be positive");
  return Math.PI * radius * radius;
}

calculateArea(5); // Works
calculateArea(-1); // Throws an error

Strict mode is especially useful for maintaining larger codebases where enforcing discipline in variable declaration, scoping, and error handling is crucial.