Writing reliable computer software is the primary goal of professional programmers. By default, Javascript is a weakly typed language — to support quick prototyping of ideas — that comes with a "strict mode" which may be enabled to catch compile-time errors and exceptions.
The public release of strict mode (in 2011) was as part of the Javascript version 5 specification. This mode counters the default permissive style with a less flexible interpretation that restricts some syntax from being used and throws more exceptions on possibly ambiguous code. This reduced, safer feature set results in more reliable and predictable software at the cost of greater defensive programming. Specifically, Javascript strict mode:
- prevents alternate octal notations
- prevents deleting undeletable properties
- prevents duplicate argument names
- prevents future naming issues
- prevents invalid variable assignments
- prevents unintentional global variables
Invoking Javascript Strict Mode
Javascript strict mode is optionally available for some scopes and always enabled for others, as shown:
enforcement scope | strict mode options |
---|---|
script-wide | optionally available |
function-by-function | optionally available |
modules | always strict |
classes | always strict |
Note please that strict mode applies only to script-wide or to individual functions. Bare block statements enclosed in braces — {}
— do not take strict mode.
Enabling Script-Wide Strict Mode
// Script-wide strict mode syntax
"use strict" ; // alternatively, 'use strict'
// script steps follow
Enabling Function-by-Function Strict Mode
function strictFunction( arguments ) { // strict
"use strict"
// function steps follow
}
function sloppyFunction( arguments ) { // not strict
// function steps follow
}
What Does Strict Mode Actually Do?
Strict mode changes some previously-tolerated mistakes (which generate informative warnings that could be ignored) into errors (that generate progress-halting fatal errors). Because JavaScript was designed to be easy for novice developers to learn and prototype, it makes forgiving assumptions about what was meant. While this smoothes the way to getting a program running, these assumptions may mask conceptual mistakes that cause far worse problems in the future. Strict mode treats these mistakes as errors so that the programmer discovers, understands, and fixes these issues immediately. It’s tough love.
Prevents Unintentional Global Variables
In the default, permissive Javascript mode, mistyping a variable name simply creates a new variable in the global namespace.
'use strict';
var length = 180 ;
lenght = 90 ; // strict mode flags this typo as an error
Prevents Invalid Variable Assignments
Javascript strict mode makes assignments which would silently fail in permissive mode to throw a blocking exception, including, variable assignments to:
- non-writable globals
- non-writable properties
- getter-only properties
- new property of a non-extensible object
Prevents Deleting Undeletable Properties
Attempting to delete a property to which you don’t have permissions is silently ignored in permissive mode; not so in strict mode.
'use strict' ;
delete Object.prototype ; // strict mode TypeError
Prevents Duplicate Argument Names
Strict mode requires that function argument names be unique. In permissive mode a duplicated argument hides previous identically-named arguments, most typically caused by a distracted programmer making a typo of a variable name.
The following example shows a defensive programming technique for Javascript’s ability to take any number of arguments (regardless of the number actually declared) being subverted by a typo in the argument list — a typo discovered and flagged in strict mode.
'use strict' ;
function mean( a, b, b ) { // should've been a, b, c
var total ;
for ( var i = 0, j = arguments.length ; i < j ; i++ ) {
total += arguments[i] ;
}
return total / arguments.length ; // mean average
}
Prevents Alternate Octal Notations
In permissive mode, numbers beginning with a zero (such as the permissions string 0644
) are considered as an octal number if all digits are less than eight.
Octal escape sequences can be used to represent characters by extended-ASCII character code; for example \45
is equivalent to the character %
.
Strict mode prevents these valid alternate forms of expressing octal numbers in favor of prefixing the octal number with 0o
, as in var c = 0o123 ;
.
The rationale for this is that novice developers may use a leading zero as an alignment device, not realizing it has a semantic meaning, as in:
'use strict' ;
var sum = 001 + // so nicely lined up...
012 +
123 ;
Before you laugh, this alignment technique has been done with IP addresses too; changing 127.0.0.1
to 127.000.000.001
completely fails because each tuple is then interpreted as octal rather than decimal.
Prevents Future Naming Issues
Javascript — like other software packages — evolves. (Version 11 is the current release; 12 was finalized in June 2021.) With future plans always under consideration strict mode makes an attempt to ease the transition by applying some restrictions. For example, the following identifiers have become reserved keywords: implements
, interface
, let
, package
, private
, protected
, public
, static
, and yield
. In strict mode neither variables nor arguments with these names may be used.
Conclusion
This blog post Javascript strict mode, how it assists programmers in writing error-free code by identifying and preventing common issues (in both current and future Javascript versions).
To learn more about Javascript, check out other Javascript blog posts and enroll in our Javascript Nanodegree programs, including Intermediate Javascript.