Codectionary / Developer documentation / JavaScript

Strict Mode

"use strict" opts your code into a restricted variant of JavaScript that catches common mistakes by turning them into errors - like accidentally creating a global variable by forgetting to declare it. ES6 modules and classes are automatically in strict mode, so most modern code benefits from it without explicitly writing the directive.

Syntax

"use strict";

Examples

Catching Accidental Globals

Strict mode throws an error instead of silently creating a global variable.

"use strict";

try {
  undeclaredVariable = 5; // ReferenceError in strict mode
} catch (e) {
  console.log(e.message);
}

// Without strict mode, this would silently create a global variable - a common bug source

Strict Mode is Automatic in Modules and Classes

You often get strict mode benefits without writing the directive at all.

// In an ES module file, this is automatic:
export function myFunction() {
  // strict mode is already active here
}

class MyClass {
  // class bodies are always strict mode, even outside modules
}

Best practices

  • If writing plain scripts (not modules), add "use strict" at the top of the file or function to catch silent errors
  • Remember ES6 modules (using import/export) and class bodies are strict mode by default - no directive needed
  • Treat strict mode errors as bugs to fix, not obstacles to work around, since they usually reveal a genuine mistake
  • Avoid mixing strict and non-strict code within the same file where possible, for consistent behavior

At a glance

Purpose
Application logic and interaction
File extension
.js · .mjs
Runs in
Browsers and JavaScript runtimes
Usually used with
HTML, CSS and Web APIs

Specifications & further reading

Related JavaScript documentation

Arrow Functions
Arrow functions provide a more concise syntax for writing function expressions in JavaScript. Introduced in ES6, they use the => syntax and have some important differences from regular functions, particularly in how they handle the "this" keyword. Arrow functions are especially useful for callbacks, array methods, and short inline functions.Variables: var, let, const
JavaScript has three ways to declare variables. var is the original way, function-scoped and hoisted with a default value of undefined. let, introduced in ES6, is block-scoped and can be reassigned. const is also block-scoped but cannot be reassigned after its initial value is set. Modern JavaScript strongly favors let and const over var.Data Types
JavaScript has seven primitive data types - string, number, boolean, undefined, null, bigint, and symbol - plus the object type, which includes arrays, functions, and plain objects. JavaScript is dynamically typed, meaning a variable can hold any type and that type can change. The typeof operator reports a value's type at runtime.Arithmetic Operators
Arithmetic operators perform mathematical calculations on numbers: addition (+), subtraction (-), multiplication (*), division (/), remainder/modulo (%), and exponentiation (**). The + operator also performs string concatenation when either operand is a string. Increment (++) and decrement (--) adjust a variable by one.