JavaScript "use strict"

---

JavaScript is a flexible and powerful language, but this flexibility sometimes leads to unexpected results and subtle bugs. Enter "use strict", a feature that helps developers write more reliable and cleaner code by enforcing stricter parsing and error handling.

What is "use strict"?

"use strict" is a directive in JavaScript that helps catch common coding mistakes by enforcing a stricter set of rules during the interpretation of your code. When this directive is applied, JavaScript will throw more errors, prevent certain actions, and make it easier to write secure and maintainable code.

Key Features of "use strict":

• It eliminates silent errors that would otherwise go unnoticed.
• It catches assignments to undeclared variables.
• It makes debugging easier by throwing more exceptions.
• It helps you avoid using reserved words in future versions of JavaScript.

How to Use "use strict"

You can enable strict mode by placing the string "use strict"; at the beginning of your JavaScript code, either in the entire script or in individual functions.

1. Applying "use strict" to an Entire Script

You can enable strict mode for the whole script by placing "use strict"; at the top of the JavaScript file.

Example: "use strict" in a Script

"use strict";

var x = 10;  // Works fine
undeclaredVariable = 20;  // Error: 'undeclaredVariable' is not defined

Here:

• The directive applies to the entire script.
• Any variable assignments or operations that are illegal in strict mode will result in an error (e.g., undeclaredVariable is not declared before being assigned).

2. Applying "use strict" to a Function

You can also apply "use strict" within individual functions, making strict mode specific to those functions.

Example: "use strict" in a Function

function myFunction() {
  "use strict";
  var y = 30;  // Works fine
  undeclaredVar = 40;  // Error: 'undeclaredVar' is not defined
}

myFunction();

In this case:

• "use strict" is only applied inside the function myFunction.
• The variable undeclaredVar will throw an error because it was not declared using var, let, or const.

Benefits of "use strict"

1. Prevents Accidental Global Variables

In non-strict mode, if you accidentally forget to declare a variable with var, let, or const, JavaScript will implicitly create a global variable. This can lead to bugs that are difficult to trace.

Example: Undeclared Variables Without Strict Mode

x = 5;  // Creates a global variable
console.log(x);  // Outputs: 5

In strict mode, this will throw an error, helping you catch such mistakes early.

Example: Undeclared Variables With Strict Mode

"use strict";
x = 5;  // Error: x is not defined
console.log(x);

Here:

• Without the need for explicit declaration, JavaScript throws an error because of strict mode, preventing unintended global variable creation.

2. Prevents Deleting Variables or Functions

Strict mode makes it illegal to delete variables or functions. This helps avoid accidental removal of essential code.

Example: Attempting to Delete Variables

"use strict";
var myVar = 10;
delete myVar;  // Error: Cannot delete variable 'myVar'

In non-strict mode, the delete operation would silently fail, which could be problematic in certain scenarios.

3. Prohibits Duplicating Function Parameter Names

Strict mode throws an error if you try to use duplicate parameter names in function definitions, which can be confusing and error-prone.

Example: Duplicating Function Parameters

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

Strict mode helps avoid confusion and ensures that parameters are distinct, making the code easier to understand.

4. Throws an Error for eval()-Related Behavior

In strict mode, the eval() function is treated differently. Code executed within eval() cannot alter variables outside of its scope, preventing unintended side effects.

Example: eval() in Strict Mode

"use strict";
eval("var x = 10;");  // Error: 'x' is not defined outside eval

In non-strict mode, eval() would allow x to be created outside its scope, leading to potential security vulnerabilities.

5. Prevents with Statements

The with statement is disallowed in strict mode because it makes the code difficult to predict and optimize. Using with can lead to ambiguity in which object properties are being accessed.

Example: Using with in Strict Mode

"use strict";
with (Math) {  // Error: Strict mode code may not include a 'with' statement
  console.log(sin(2));  // Works, but `with` is not allowed
}

In non-strict mode, the with statement is allowed but can lead to confusing code, which is why it’s forbidden in strict mode.

Differences Between Strict Mode and Non-Strict Mode

Let’s compare how JavaScript behaves in strict mode vs. non-strict mode:

Feature	Non-strict Mode	Strict Mode
Undeclared variables	Automatically becomes global	Throws an error
Deleting variables/functions	Works, but has no effect	Throws an error
Duplicate parameter names	Allowed	Throws an error
eval() scope	Variables in eval() affect outer scope	Variables in eval() don’t affect outer scope
with statement	Allowed	Throws an error

Common Pitfalls of "use strict"

While "use strict" helps avoid many issues, there are some pitfalls to be aware of:

1. Strict Mode Does Not Apply in Global Scope in Older Browsers

Some older JavaScript environments (such as older browsers) might not fully support strict mode. Be sure to test your code across different platforms.

2. Legacy Code

When adding "use strict" to existing code, be aware that some older code might break due to previously tolerated practices (e.g., assignments to undeclared variables, use of with, etc.). It’s a good practice to test thoroughly when applying strict mode to legacy code.

Best Practices for Using "use strict"

1. Enable Strict Mode by Default: Use "use strict"; at the beginning of your scripts or functions to catch potential errors early in the development process.

2. Apply to Individual Functions: If you're working with legacy code or modules, apply strict mode only to specific functions to avoid breaking old code.

3. Refactor Legacy Code: If you’re adding strict mode to legacy code, refactor to ensure that variables are declared correctly and that there are no issues with deleted variables or with statements.

4. Use Modern JavaScript Features: Many modern JavaScript features (like let, const, and arrow functions) are already strict mode-compliant. Incorporating these features into your code will help ensure that it’s compatible with strict mode.

---

---