Strict Mode with 'use strict' in JavaScript

As we all know that JavaScript is a very lenient language in terms of showing errors, usage of variables, type declaration of variable etc which is a double ended sword. Hence the introduction of the strict mode in ECMAScript 5 which allows you to compile and execute your code in a "strict" operating context hence you will see more exceptions with more information shared with the developers.

It's good because it will force you to write good code. It's a perfection depiction of the quote "Fail fast and fail loudly".

Now before getting to the features of "use strict", let's learn how to use it.

---

How to enable Strict Mode?

To enable strict mode for your javascript code, all you have to do is add the string "use strict" at the beginning of the code.

To make enable strict mode for the entire code in a single JS file, add "use strict" as the first line of code

"use strict";

/*

    Your javascript code

*/

Also, we can enable strict mode for some specific functions too, which will enable strict mode for only that particular function.

function iamStrict()

{

    "use strict";

    // your javascript code

}

The syntax is neat and just a string that has to be added, nothing else. Now that we know how to use it, let's learn what it brings along - it's features.

---

Features of "use strict" statement

First of all, the features of ECMAScript 3 which are deprecated in ECMAScript 5 will lead to exception. They will not be ignored silently. Apart from this, following are a few ill-coding habits that "use strict" prohibits:

1. No Implicit Global Variables

One cannot use global variables without declaration. Also any variable declaration using var is not considered as global variable implicitly. To define a variable as global, you must explicitly specify that,

var foo = "bar" // not a global variable

window.foo = "bar" // global variable

Also, if we try to assign foo="bar"; before defining foo variable will fail.

2. More Exceptions and Error

All the silent failing assignments or other errors will lead to exceptions.

Nan = 5; // lead to exception

3. delete doesn't work

You cannot use the delete keyword to delete properties which have their configurable property set to false. For example, the following will lead to error,

function test(arg)

{

    delete arg; // ERROR

}

4. Duplicate Property name in Object Literal

If we try to define a property more than once in an object literal we will get error. For example,

var x = {x1: "1", x1: "2"}    // will give error

5. eval is prohibited

Almost any use of eval is prohibited, so no assignment, no introduction of new variables using eval and also you cannot use eval as function name or as argument to any function

obj.eval = ...    // ERROR

obj.foo = eval;    // ERROR

function eval() { ... }    // ERROR

// introducing new variable using eval

eval("var a = false;");    // ERROR

6. No more with statements

While working with strict mode on, we cannot use with statements anymore. In fact you will get a syntax error for it.

7. Restriction in Functions

Identical names for arguments is not allowed.

function(foo, foo) { ... }    // ERROR

Also accessing arguments.caller and arguments.callee functions will also throw an exception.

So these are some of the restrictions that "use strict" will impose on your code, and many of these are just good practices that the strict mode makes compulsory for every developer to follow.

---

Word of Caution

"use strict" is not something that you apply on your code and the code becomes better, NO! Applying "use strict" to existing code can lead to errors and exceptions. Hence it is always advised to have proper unit test cases in place for large applications to test changes in code including applying strict mode to your code.

But yes, strict mode should be enabled for important code libraries to make sure the code is full proof. Rest, it's your decision.