JavaScript Strict Mode ('use strict') Explained

JavaScript was designed to be forgiving. Misspell a variable name? JavaScript silently creates a global. Assign to a read-only property? JavaScript shrugs and moves on. This tolerance was useful in the early days of the web, but it became a source of hard-to-find bugs as applications grew.

Strict mode, introduced in ECMAScript 5, changes this behavior. When you opt into strict mode with 'use strict', JavaScript throws errors for actions it would normally ignore silently. Think of it like switching your code editor from "ignore all warnings" to "treat warnings as errors." The same code runs, but now the language actively tells you when something looks wrong.

This tutorial covers what strict mode does, how to enable it, the specific errors it catches, and when you should (and should not) use it in your projects.

What Is JavaScript Strict Mode?

Strict mode is a restricted variant of JavaScript that eliminates some silent errors, fixes mistakes that make it difficult for engines to perform optimizations, and prohibits syntax that may conflict with future ECMAScript versions. It does not add new features; it changes how existing features behave.

When strict mode is active, JavaScript:

• Throws errors instead of silently failing
• Prevents accidental creation of global variables
• Disallows duplicate parameter names
• Makes eval and arguments behave more predictably
• Blocks the use of deprecated or reserved syntax

Why Was Strict Mode Created?

JavaScript's original design allowed many operations that seemed convenient but caused real problems at scale:

The ECMAScript committee could not simply change the default behavior because millions of existing websites depended on the lenient rules. Instead, they made strict mode opt-in so developers could adopt it file by file or function by function.

How to Enable Strict Mode

Strict mode is enabled by placing the string 'use strict'; (or "use strict";) at the very top of a script or function body. The position matters: it must be the first statement, before any other code.

Enabling Strict Mode for an Entire Script

Place 'use strict'; at the top of your JavaScript file, before any other statements:

javascript

'use strict';
 
let userName = 'Alice';
console.log(userName);
 
// This would throw a ReferenceError in strict mode:
// mistypedVariable = 'oops'; // ReferenceError: mistypedVariable is not defined

Every line of code in this file runs under strict mode rules. If any code violates those rules, the engine throws an error immediately instead of failing silently.

Enabling Strict Mode for a Single Function

If you only want strict mode inside a specific function, place the directive as the first statement inside the function body:

javascript

function processPayment(amount) {
  'use strict';
  
  // All code inside this function runs in strict mode
  let total = amount * 1.08; // tax calculation
  
  // Accidentally omitting 'let' would throw an error here:
  // result = total; // ReferenceError: result is not defined
  
  return total;
}
 
// Code outside the function runs in normal (sloppy) mode
globalVar = 'this still works out here'; // no error in normal mode

This approach is useful when you need strict mode in new code but are working within a codebase that relies on normal mode behavior elsewhere.

ES6 Modules Are Always in Strict Mode

If you write modern JavaScript using import and export syntax, your code is automatically in strict mode. You do not need the 'use strict' directive:

javascript

// This file uses ES6 module syntax, so strict mode is automatic
import { formatCurrency } from './utils.js';
 
export function calculateTotal(items) {
  // Strict mode is already active here
  let total = items.reduce((sum, item) => sum + item.price, 0);
  return formatCurrency(total);
}

How Strict Mode Changes JavaScript Behavior

Strict mode modifies several key behaviors. Here are the most important changes, each with a concrete example.

Prevents Accidental Global Variables

In normal mode, assigning a value to a variable that was never declared creates a property on the global object. This is one of the most common sources of bugs in JavaScript:

javascript

'use strict';
 
function calculateShippingCost(weight, distance) {
  // Typo: 'baseCost' instead of 'base_cost'
  baseCost = weight * 0.5; // ReferenceError: baseCost is not defined
  
  let base_cost = weight * 0.5;
  let distanceFee = distance * 0.02;
  return base_cost + distanceFee;
}
 
calculateShippingCost(10, 50);

Without strict mode, baseCost would silently become a global variable, and the function would return NaN because base_cost is undefined. With strict mode, you get an immediate ReferenceError pointing directly at the typo.

Makes Assignment Failures Throw Errors

In normal mode, assigning to read-only properties, non-writable properties, or getters without setters fails silently:

javascript

'use strict';
 
const config = {};
Object.defineProperty(config, 'apiUrl', {
  value: 'https://api.example.com',
  writable: false,
});
 
// In normal mode, this silently fails. In strict mode:
config.apiUrl = 'https://hacked.com'; // TypeError: Cannot assign to read only property 'apiUrl'

This also applies to built-in read-only properties:

javascript

'use strict';
 
undefined = 42;      // TypeError: Cannot assign to read only property 'undefined'
NaN = 'not a number'; // TypeError: Cannot assign to read only property 'NaN'
Infinity = 0;        // TypeError: Cannot assign to read only property 'Infinity'

Prevents Deletion of Undeletable Properties

javascript

'use strict';
 
// Attempting to delete a non-configurable property
delete Object.prototype; // TypeError: Cannot delete property 'prototype' of function Object()

Changes this Behavior in Functions

In normal mode, this inside a regular function call defaults to the global object (window in browsers, global in Node.js). In strict mode, this is undefined:

javascript

'use strict';
 
function showContext() {
  console.log(this); // undefined (not the global object)
}
 
showContext();

This change prevents a common class of bugs where methods accidentally modify the global object. It forces you to be explicit about what this refers to.

Disallows Duplicate Parameters

javascript

'use strict';
 
// SyntaxError: Duplicate parameter name not allowed in this context
function merge(obj, obj) {
  // In normal mode, the second 'obj' silently shadows the first
  return obj;
}

Restricts eval Scope

In strict mode, variables declared inside eval do not leak into the surrounding scope:

javascript

'use strict';
 
eval('var leakyVariable = 42;');
console.log(typeof leakyVariable); // "undefined" (strict mode prevents leaking)
 
// In normal mode, leakyVariable would be 42

Strict Mode vs Normal (Sloppy) Mode Comparison

Best Practices

Use ES6 modules whenever possible. Modules are strict by default, which eliminates the need to manually add 'use strict' to every file. If your project uses a bundler like Webpack or Vite, you are likely already writing modules.

Add 'use strict' to all non-module scripts. If you write scripts that load via <script> tags without type="module", place 'use strict' at the top of every file. This catches bugs early and prepares your code for eventual migration to modules.

Never place 'use strict' after code. The directive only works when it is the very first statement. If any expression or statement precedes it, the engine treats it as a regular string expression and ignores it.

Be cautious when concatenating strict and non-strict files. If you combine a strict-mode file and a non-strict-mode file into one bundle, the result depends on which file comes first. Bundlers handle this correctly for modules, but legacy concatenation scripts may not.

Test after enabling strict mode. When adding strict mode to an existing codebase, run your full test suite. Code that worked in normal mode may throw errors under strict mode, especially if it relies on implicit globals or sloppy this behavior.

Common Mistakes and How to Avoid Them

Placing 'use strict' after a regular statement. The directive must be the first statement in a script or function. Even a simple variable declaration before it will silently disable it:

javascript

let x = 10;
'use strict'; // This is now just a string expression, NOT a directive
y = 20;       // No error — strict mode is not active

Assuming this is always the global object. In strict mode, this is undefined in plain function calls. If your code accesses this.someProperty inside a utility function, it will throw a TypeError instead of reading from the global object.

Forgetting that eval behaves differently. Code using eval to create variables in the calling scope will break under strict mode because eval variables stay contained within the eval call.

Using octal literals for file permissions. If you work with file systems and use octal numbers like 0644, strict mode will throw a SyntaxError. Use the explicit 0o644 syntax instead, which is valid in both modes.

Not checking third-party libraries. Some older libraries rely on normal-mode behaviors like implicit globals. Wrapping them in a strict-mode context can cause unexpected ReferenceError exceptions.

When to Use (and Not Use) Strict Mode

Next Steps