JavaScript Use Strict

The “use strict” directive is a way to opt into a restricted variant of JavaScript. It helps you write cleaner code and avoid common pitfalls.

The “use strict” Directive

“Use strict” was introduced in ECMAScript 5 (ES5) to enforce stricter parsing and error handling in JavaScript. This directive is a simple string that can dramatically improve your code quality.The “use strict” directive is widely supported across modern browsers, including:

Declaring Strict Mode

You can enable strict mode by adding the string “use strict” at the beginning of your script or function. Once enabled, the code will run in strict mode, applying its rules.

Example:

“use strict”; x = 3.14; // Error: x is not defined

Without strict mode, JavaScript would have allowed the assignment x = 3.14 and automatically created a global variable. With strict mode, this generates an error, helping you avoid such mistakes.

The “use strict” Syntax

To use strict mode, simply write: “use strict”; This directive must be at the top of the script or inside a function

Why Strict Mode?

Strict mode offers several benefits:

Prevents the use of undeclared variables.
Eliminates silent errors by throwing exceptions.
Disables certain JavaScript features that are considered problematic.
Makes the code easier to debug and maintain

Not Allowed in Strict Mode

Strict mode disallows some common mistakes, such as:

Using a variable without declaring it: “use strict”; x = 10; // Error: x is not defined

Using an object without declaring it:

“use strict”; myObj = { name: “John” }; // Error: myObj is not defined

Deleting a variable (or object):

“use strict”; let x = 10; delete x; // Error: Cannot delete variable ‘x’

Deleting a function:

“use strict”; function myFunction() {} delete myFunction; // Error: Cannot delete function

Duplicating a parameter name:

“use strict”; function myFunction(a, a) { // Error: Duplicate parameter name not allowed return a;

Using octal numeric literals:

“use strict”; let num = 012; // Error: Octal literals are not allowed

Using octal escape characters:

“use strict”; let str = “\012”; // Error: Octal escape sequences are not allowed

Writing to a read-only property:

“use strict”; const obj = Object.freeze({ key: “value” }); obj.key = “newValue”; // Error: Cannot assign to read-only property ‘key’

Writing to a get-only property:

“use strict”; const obj = { get prop() { return 42; } }; obj.prop = 50; // Error: Cannot set property ‘prop’

Deleting an undeletable property:

“use strict”; delete Object.prototype; // Error: Cannot delete property ‘prototype’

Using eval as a variable:

“use strict”; eval = 10; // Error: ‘eval’ cannot be used as a variable

Using arguments as a variable:

“use strict”; arguments = []; // Error: ‘arguments’ cannot be used as a variable

Using the with statement:

“use strict”; with (Math) { // Error: ‘with’ is not allowed in strict mode console.log(PI); }

Creating variables with eval() in the local scope:

“use strict”; eval(“var x = 10;”); console.log(x); // Error: x is not defined

Using a variable before declaration:

“use strict”; console.log(y); // Error: Cannot access ‘y’ before initialization let y = 20;

Declaring variables with var inside eval:

“use strict”; eval(“var x = 5;”); // Error: Variables declared inside eval cannot be accessed outside

Declaring variables with let inside eval:

“use strict”; eval(“let y = 10;”); // Error: Variables declared inside eval cannot be accessed outside.

In strict mode, keywords that are reserved for later JavaScript versions cannot be used as variable names.

implements
interface
let
package
private
protected
public
static
yield

Attempting to use these reserved keywords will result in a syntax error, ensuring compatibility with future JavaScript versions.

Request more information

JavaScript Use Strict