JavaScript

Strict Mode in JavaScript | Explained

As JavaScript is a scripting language, sometimes it shows the correct output even if it contains any errors. You can use the “Strict Mode” in JavaScript to cope with this situation. The JavaScript engine executes the script with additional restrictions checks when Strict Mode is enabled.

Strict Mode in JavaScript is a restricted variant or semantical stricter that generates errors for the issue, which the engine might handle silently. In this Mode, the deprecated JavaScript features are also caught up, and the related error will be then shown as output. As a result, Strict Mode enhances security, minimizes bugs, and boosts your JavaScript application’s performance.

This write-up discusses Strict Mode in JavaScript along with suitable examples. So, let’s start!

How to enable Strict Mode in JavaScript

By utilizing the “use strict” string, you can enable “Strict Mode” and add it to the global scope for the entire script or apply it to a single function only.

We will now practically go through both of the mentioned ways.

Enabling Strict Mode for whole script in JavaScript

If you want to enable Strict Mode for the whole script, then add the “use strict” string at the start of the script, and write out the required code in the following way:

'use strict';
// other script code
x = 5;
console.log(x);

After executing the above script, we have got a “ReferenceError” because, in Strict Mode, you cannot use variables without defining them:

Enabling Strict Mode for a single function in JavaScript

To enable “Strict Mode” within a function, add the “use strict” string at the function definition’s beginning.

For instance, in the below-given script, we activated “Strict Mode” only for the “displayInfo()” function:

x = 6;

console.log(x);

function displayInfo() {

   'use strict';

    y = "linuxhint";

    console.log(y);

  }

  displayInfo();

Output

In the given output, you may have noticed that enabling Strict Mode has applied some restrictions to the script, resulting in some errors. To know more about the “not allowed” kind of restrictions within the JavaScript Strict Mode, have a look at the upcoming section.

Undeclared variables within Strict Mode in JavaScript

In JavaScript Strict Mode, a variable cannot be initialized or used as an undeclared variable.

Example: Undeclared variable with Strict Mode in JavaScript

'use strict';
x = 'linuxhint';

We have not declared the “x” variable in the above-given example. So, initializing it with the value “linuxhint” will throw the following “ReferenceError”:

Undeclared objects within Strict Mode in JavaScript

Similarly, in Strict Mode, all added objects must be declared first. In case you are assigning properties and their respective values for an undeclared object, the JavaScript engine will throw a “ReferenceError”:

Example: Undeclared objects with Strict Mode in JavaScript

'use strict';
employee = {name: 'Alex', age: 33};

Output

Deleting objects within Strict Mode in JavaScript

JavaScript does not permit you to delete objects in Strict Mode. If you do so, a SyntaxError will be thrown in the console window.

Example: Deleting objects within Strict Mode in JavaScript

'use strict';
let employee = {name: 'Alex', age: 33};
delete employee;

Output

In “Non-Strict” Mode, the attempt to delete the created “employee” object will fail silently the the “delete employee” expression will be evaluated as “false”:

Duplicating Parameters within Strict Mode in JavaScript

A function declaration in Strict Mode must have unique parameters name as duplicating the parameter name will throw a SyntaxError.

Example: Duplicate Parameters within Strict Mode in JavaScript

In the below-given example, we have defined a “showInfo()” function that comprises duplicate parameters (a, a):

"use strict";
functionshowInfo(a, a) { console.log('Strict Mode in JavaScript')};
showInfo();

Execution of the provided code will throw a “SyntaxError: Duplicate parameter name not allowed in this context”:

Read-only property within Strict Mode in JavaScript

Strict Mode restricts the writing access of a read-only property.

Example: Read-only property within Strict Mode in JavaScript

For instance, we will declare an “object1” having a “y” property in Strict Mode and then set its “writable” property to “false”. Upon doing so, the “y” property of “object1” is converted into read-only or non-writable property:

'use strict';

let object1 = {};

Object.defineProperty(object1, 'y', { value: 12, writable: false });

Next we will assign a new value to the “object1.y” property:

object1.y = 56;

Assigning value to the read-only “object1” property displays a TypeError:

Octal literals within Strict Mode in JavaScript

Numerals that comprise “zero” as a prefix are called Octal literals, and they are not allowed in JavaScript Strict Mode.

Example: Octal literals within Strict Mode in JavaScript

The following example will create an octal literal “x” with the value “001”:

'use strict';

let x = 001;

As mentioned earlier, the strict does not permit to define Octal literals, so you may encounter the following SyntaxError:

Instead of utilizing “0” as a prefix, adding “0o” will solve the issue:

'use strict';

let x = 0o01;

console.log(x);

Now, we have successfully created an Octal literal within the Strict Mode using the “0o” prefix:

eval and arguments within Strict Mode in JavaScript

In Strict Mode, you cannot utilize “eval” and “arguments” as function names, variable names, or function parameters. Both “eval” and “arguments” are treated as “keywords” within the JavaScript Strict Mode.

Example: eval and arguments within Strict Mode in JavaScript

'use strict';

let eval = 32;

let arguments = 'linuxhint';

Using “eval” and “arguments” as variable names will output the following SyntaxError:

Non-extensible object within Strict Mode in JavaScript

The Strict Mode in JavaScript does not allow adding new properties to a created non-extensible object.

Example: Non-extensible object within Strict Mode in JavaScript

Firstly, we will declare an “object3” and convert it to a non-extensible object by utilizing the “Object.preventExtensions()” method. After that, we will attempt to add a “newProperty” to “object3”:

'use strict';

let object3 = {};

Object.preventExtensions(object3);

object3.newProperty = 'my object';

The given output signifies that the created object is not extensible; therefore, we cannot add a new property:

Why use Strict Mode in JavaScript

Here is the list of some of the fantastic advantages of using Strict Mode in JavaScript:

  • Strict Mode assists in writing a secure and cleaner script.
  • It eliminates the function of hiding silent JavaScript errors by throwing an error statement.
  • Fixing faults with the help of JavaScript Strict mode optimizes the code and the JavaScript engine executes it quickly compared to the code written in non-strict Mode.

We have provided the essential information related to Strict Mode, its advantages, and restrictions in JavaScript.

Conclusion

By utilizing the “use strict” string, you can enable Strict Mode in JavaScript in the global context of a script or for a single function. It improves JavaScript semantics by providing extra security. When Strict Mode is enabled in a script, undeclared variables and objects cannot be used. It does not permit adding duplicate parameters, Octal literals, deleting objects, and writing into read-only object’s property. This write-up explained Strict Mode in JavaScript along with appropriate examples.

About the author

Sharqa Hameed

I am a Linux enthusiast, I love to read Every Linux blog on the internet. I hold masters degree in computer science and am passionate about learning and teaching.