JavaScript - Strict Mode

Hello there, future JavaScript wizards! Today, we're going to dive into a topic that might sound a bit intimidating at first, but I promise you, it's going to be as fun as finding an extra french fry at the bottom of your takeout bag. We're talking about JavaScript's Strict Mode!

Strict Mode in JavaScript

Imagine you're learning to drive. At first, your instructor might be lenient with you, letting small mistakes slide. But as you progress, they start to be more strict, pointing out every little error. That's exactly what JavaScript's Strict Mode does – it's like a strict driving instructor for your code!

Strict Mode is a feature introduced in ECMAScript 5 (ES5) that allows you to place a program, or a function, in a "strict" operating context. This strict context prevents certain actions from being taken and throws more exceptions.

Enabling Strict Mode

Enabling Strict Mode is as easy as pie (and who doesn't love pie?). You simply need to add the string "use strict" at the beginning of your script or function. Let's see how it looks:

"use strict";

// Your code here

That's it! You've just enabled Strict Mode for your entire script. But remember, it's like putting on a seatbelt – it only works if you do it at the start!

Why Use the Strict Mode?

Now, you might be wondering, "Why would I want to make JavaScript stricter? Isn't it already complicated enough?" Well, my young padawan, Strict Mode is actually here to help you. Here are some reasons why you might want to use it:

1. It catches common coding bloopers, throwing exceptions.
2. It prevents, or throws errors, when relatively "unsafe" actions are taken.
3. It disables features that are confusing or poorly thought out.
4. It makes your code more secure.
5. It helps you write "cleaner" code.

Let's look at a simple example:

"use strict";

x = 3.14; // This will cause an error

Without Strict Mode, JavaScript would happily create a global variable x. But with Strict Mode, it throws an error because you forgot to declare the variable with let, const, or var. It's like having a friend who always reminds you to tie your shoelaces!

Strict Mode in the Global Scope

When you use Strict Mode in the global scope (outside of any function), it applies to the entire script. Here's an example:

"use strict";

function doSomething() {
    x = 10; // This will cause an error
}

doSomething();

In this case, even though x = 10 is inside a function, it will still cause an error because Strict Mode is enabled for the entire script.

Strict Mode in the Local Scope

You can also use Strict Mode within a specific function. This is useful when you're working on a large project and only want to apply Strict Mode to a particular part of your code. Here's how you do it:

function strictFunction() {
    "use strict";
    // This function is in strict mode
    y = 20; // This will cause an error
}

function nonStrictFunction() {
    // This function is not in strict mode
    z = 30; // This will not cause an error
}

strictFunction();
nonStrictFunction();

In this example, strictFunction() will throw an error, but nonStrictFunction() won't. It's like having a "No Shoes, No Shirt, No Service" sign, but only for one room in your house!

Mistakes that you shouldn't make in the strict mode

Now, let's talk about some common mistakes that Strict Mode will catch. Think of these as the "don'ts" of Strict Mode:

Mistake	Example	Explanation
Using undeclared variables	x = 3.14;	Variables must be declared with let, const, or var
Using delete on variables	delete x;	You can't delete variables, functions, or arguments
Duplicating parameter names	function f(a, a, b) {}	No duplicate parameter names allowed
Using octal syntax	var n = 023;	Octal syntax is not allowed
Writing to a read-only property	var obj = {}; Object.defineProperty(obj, "x", { value: 0, writable: false }); obj.x = 3.14;	Can't write to read-only properties
Using with statement	with (Math) { x = cos(2); }	The with statement is not allowed

Let's look at a more complex example that demonstrates some of these rules:

"use strict";

function calculateArea(radius, radius) {
    // Duplicate parameter name - this will cause an error
    with (Math) {
        // Using 'with' statement - this will cause an error
        return PI * radius * radius;
    }
}

var result = calculateArea(5, 5);
console.log(result);

This code has two issues: duplicate parameter names and the use of the with statement. Strict Mode will catch both of these and throw errors, helping you write better, more maintainable code.

In conclusion, Strict Mode is like having a super-smart, slightly pedantic friend looking over your shoulder as you code. It might seem annoying at first, but it's there to help you become a better JavaScript developer. So embrace it, use it, and watch your code quality soar!

Remember, in the world of programming, being strict isn't about being mean – it's about being clear, precise, and error-free. So go forth and code strictly, my friends!

Credits: Image by storyset