JavaScript strict mode


JavaScript strict mode is an innovative feature in ECMAScript 5. It enables us to place a program in a strict operating perspective. This strict context stops definite actions from being taken and throws additional exceptions.

The declaration uses strict initiates the browser to use the strict mode. It is a compact and safer feature set of JavaScript. The drive of using strict literal is to specify that the code should be implemented in the strict mode. It supports us to categorize some hidden bugs. We can’t practice undeclared variables in strict mode.

In this article, we will go through the overview of strict mode in JavaScript.


JavaScript’s strict mode is a method to pick a limited variant of JavaScript. In that way indirectly opting-out of sloppy mode. Strict mode deliberately has diverse semantics from normal code. Browsers, not backup strict mode will run the code with different behavior from browsers that do. Therefore, don’t depend on a strict mode without feature-testing to support the pertinent features of a strict mode.


  • Strict mode creates various changes to normal JavaScript semantics.
  • It removes different JavaScript silent errors by changing them to throw errors.
  • It repairs mistakes that mark it difficult for JavaScript engines to do optimizations.
  • Strict mode code may occasionally be completed to run faster than matching code that’s not strict mode.
  • It forbids some syntax possible to be defined in future versions of ECMAScript.
  • Strict mode stops when comparatively unsafe actions are taken.
  • For example, fast access to the global object.
  • Strict mode restricts features that are unclear or ill-thought-out.
  • It makes it relaxed to write secure JavaScript.

Why should we use strict mode?

There are several benefits of using a strict mode style in JavaScript. One easy thing is if we are defining a variable in a global state. For example, deprived of identifying var command as mentioned below.

"use strict";
globalVar = "evil"

This is going to be an error in strict mode. That’s a good catch for our developers, as global variables are very foul in JavaScript. On the other hand, there wouldn’t have been complaints about the error if the same code were run in non-strict mode. The same code in JavaScript may produce not the same results whether we’re running in strict or non-strict mode.

Use of strict mode

There are two ways to use the strict mode

  • Used in global scope for the whole script.
  • It may be implemented in individual functions.

Keep in mind that strict mode doesn’t work with block statements enclosed in {} braces.

Global scope for the whole script:

  • Put the exact statement used strictly to invoke strict mode for an entire script.
  • Similarly, use strict before any other statements.
// Whole-script strict mode syntax
'use strict';
 let v = "strict mode script!";
  • This is impossible to sightlessly concatenate non-conflicting scripts.
  • Try to concatenate a strict mode script with a non-strict mode script.
  • The whole concatenation looks strict as the inverse is similarly true.

Strict mode for a function

  • Put the exact statement used strictly to invoke strict mode for a function.
  • Also, use strictly in the function’s body before any other statements.
function strict() {
  // Function-level strict mode syntax
  'use strict';
  function nested() { return 'And so am I!'; }
  return "Hi!  I'm a strict mode function!  " + nested();
function notStrict() { return "I'm not strict."; }

Not allowed in the strict mode

  • The practice of undefined variables
  • Reserved keywords use as variable or function name
  • Matching properties of an object
  • Identical parameters of the function
  • Allocate values to read-only properties
  • Adjusting arguments object
  • Octal numeric literals
  • with statement
  • eval function to generate a variable

Securing JavaScript

  • We use strict modes to make it easier to write secure and safe JavaScript.
  • Its tractability makes it well incredible to do this deprived of many runtime checks.
  • A few strict mode twists, and over needful that user-submitted JavaScript be strict mode code.
  • That it be invoked in a definite manner, considerably decrease the need for those runtime orders.
  • The value distributed as this to a function in strict mode is not required into being an object.
  • This is at all times an object for a normal function.
'use strict';
function fun() { return this; }
console.assert(fun() === undefined);
console.assert( === 2);
console.assert(fun.apply(null) === null);
console.assert( === undefined);
console.assert(fun.bind(true)() === true);


  • The strict mode in JavaScript makes it easier to write secure JavaScript.
  • It deviates before accepting bad syntax into real errors.
  • The developer would not obtain any error feedback assigning values to the non-writable properties in standard JavaScript.
  • Some assignments to the non-writable property in strict mode will throw an error.
  • Reserved keywords for future JavaScript versions cannot be used as the variable names in strict mode.
  • The strict mode by default is not required in case we are using a browser console to test any feature. We essential to add manually by using use strict.

Mansoor Ahmed

Mansoor Ahmed is Chemical Engineer, web developer, a Tech writer currently living in Pakistan. My interests range from technology to web development. I am also interested in programming, writing, and reading.