What is use strict and why is it used?

In JavaScript, "use strict" is a directive that enables strict mode, which is a way to opt into a restricted variant of JavaScript. This mode helps developers write cleaner and more secure code by enforcing stricter parsing and error handling on their JavaScript code. By using "use strict", developers can catch common coding mistakes and "unsafe" actions, such as defining global variables unintentionally.

Strict mode can be applied to entire scripts or individual functions, and it changes the way that JavaScript behaves in several important ways. Below, we will explore the key features of strict mode, best practices for its use, and common mistakes to avoid.

Key Features of Strict Mode

Strict mode introduces several changes to the language that help prevent common errors:

• Elimination of Silent Errors: In non-strict mode, certain errors fail silently. For example, assigning a value to an undeclared variable creates a global variable. In strict mode, this will throw a ReferenceError.
• Preventing Duplicate Parameter Names: Strict mode does not allow duplicate parameter names in function declarations. This helps avoid confusion and potential bugs.
• Read-Only Properties: Strict mode makes it impossible to assign values to read-only properties, which helps prevent accidental modifications.
• Disallowing `this` in Global Context: In strict mode, if a function is called without an explicit context, `this` will be `undefined` instead of the global object.
• Securing `eval`: Code executed inside an `eval` function does not have access to the outer scope, which helps avoid scope pollution.

How to Enable Strict Mode

To enable strict mode, you can place the directive at the top of a JavaScript file or at the beginning of a function. Here’s how you can do it:

"use strict"; // This applies strict mode to the entire script

function myFunction() {
    "use strict"; // This applies strict mode only to this function
    // Function code here
}

Best Practices for Using Strict Mode

Implementing strict mode is a best practice for modern JavaScript development. Here are some recommendations:

• Use it in all your scripts: By default, it’s a good idea to use strict mode in all your JavaScript files to avoid potential pitfalls.
• Apply it to functions: If you are working with legacy code, you can apply strict mode to individual functions to gradually improve code quality.
• Combine with ES6 Features: Many ES6 features, such as classes and modules, are in strict mode by default. Leveraging these features can enhance code safety and maintainability.

Common Mistakes to Avoid

While using strict mode can improve your code, there are some common mistakes developers make:

• Forgetting to Enable Strict Mode: One of the most common mistakes is forgetting to add the "use strict" directive, which can lead to unexpected behavior.
• Using Non-Strict Code in Strict Mode: Some older libraries or code may not be compatible with strict mode. Ensure that all your dependencies are compatible before enabling it.
• Misunderstanding `this`: Developers may expect `this` to refer to the global object in strict mode, but it will be `undefined` instead. This can lead to confusion and bugs.

Practical Example

Here’s a practical example that illustrates the differences between strict and non-strict mode:

function nonStrictFunction() {
    x = 10; // This creates a global variable
    console.log(x);
}

function strictFunction() {
    "use strict";
    y = 20; // This will throw a ReferenceError
    console.log(y);
}

nonStrictFunction(); // Outputs: 10
strictFunction(); // Throws ReferenceError: y is not defined

In conclusion, "use strict" is a powerful tool in JavaScript that helps developers write safer and more reliable code. By understanding its features, best practices, and common mistakes, developers can leverage strict mode to enhance their coding practices and avoid pitfalls that could lead to bugs and security vulnerabilities.