# What Is Strict Mode in JavaScript and What Does It Prevent?

> Discover strict mode in JavaScript. Learn how this ECMAScript 5 feature prevents silent errors, avoids accidental global variables, and optimizes code for better performance.

- Repository: [Kyle Simpson/You-Dont-Know-JS](https://github.com/getify/You-Dont-Know-JS)
- Tags: deep-dive
- Published: 2026-02-24

---

**Strict mode is an opt-in ECMAScript 5 feature that eliminates silent errors, prevents unsafe actions like accidental global variables, and allows JavaScript engines to optimize code execution by enforcing stricter parsing and runtime rules.**

Strict mode in JavaScript represents one of the most important shifts in the language's evolution toward safer, more predictable code. Introduced in ES5, this feature is extensively documented throughout the *You-Dont-Know-JS* repository (2nd edition), where author Kyle Simpson explains how the `"use strict"` pragma transforms JavaScript's behavior from "sloppy mode" into a constrained environment that catches common pitfalls at parse time or runtime.

## What Is Strict Mode in JavaScript?

Strict mode is a special execution context enabled by the pragma `"use strict";` that applies a set of **strict-mode controls** to JavaScript code. According to [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md), when this directive appears at the top of a script or function body, the JavaScript engine applies stricter parsing and runtime semantics that prevent certain actions and throw exceptions for historically tolerated mistakes.

The feature serves dual purposes: it **catches silent errors** that would otherwise pass unnoticed in non-strict code, and it **enables engine optimizations** by guaranteeing that certain unsafe dynamic behaviors cannot occur, allowing compilers to make stronger assumptions about variable resolution and object structure.

## What Does Strict Mode Prevent? Key Restrictions

The *You-Dont-Know-JS* source code documents specific categories of errors that strict mode prevents. These restrictions transform many silent failures into explicit exceptions.

### Eliminating Accidental Global Variables

In non-strict JavaScript, assigning to a variable without declaring it creates a new property on the global object. As noted in [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md), strict mode changes this behavior to throw a **ReferenceError** instead.

```javascript
"use strict";

function createAccidentalGlobal() {
  // Without strict mode, this would create window.x
  x = 10; // ReferenceError: x is not defined
}

createAccidentalGlobal();

```

### Preventing Assignments to Non-Writable Properties

Strict mode prevents silent failures when attempting to modify frozen or sealed objects. According to [`types-grammar/ch2.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/types-grammar/ch2.md), assignments to non-writable properties, getter-only properties, or non-existent properties on sealed objects throw **TypeErrors** rather than failing silently.

```javascript
"use strict";

const obj = {};
Object.defineProperty(obj, "id", { 
  value: 42, 
  writable: false 
});

// Silent failure in non-strict mode
obj.id = 7; // TypeError in strict mode

```

### Restricting the delete Operator

The `delete` operator behaves more predictably in strict mode. As documented in [`objects-classes/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/objects-classes/ch1.md), attempting to delete plain variables, functions, or non-configurable properties throws a **SyntaxError** or **TypeError**.

```javascript
"use strict";

var foo = 1;
delete foo; // SyntaxError in strict mode

function bar() {}
delete bar; // SyntaxError in strict mode

```

### Securing this Binding

One of the most significant behavioral changes concerns the `this` keyword. According to [`objects-classes/ch4.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/objects-classes/ch4.md) and [`get-started/ch3.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch3.md), strict mode prevents the default binding of `this` to the global object. Instead, `this` remains `undefined` in simple function calls, preventing accidental global mutations.

```javascript
"use strict";

function showThis() {
  console.log(this); // undefined in strict mode
}

showThis();

// Prevents accidental global pollution:
function setGlobal() {
  this.value = 42; // TypeError: Cannot set property 'value' of undefined
}
setGlobal();

```

### Blocking Duplicate Parameter Names

Strict mode enforces cleaner function signatures. As noted in [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md), duplicate parameter names in function declarations cause a **SyntaxError** at parse time.

```javascript
"use strict";

// SyntaxError: Duplicate parameter name not allowed in this context
function add(a, a) {
  return a + a;
}

```

### Disabling Dangerous Features (eval, with, octal)

Strict mode eliminates several historically problematic features. According to [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md) and [`types-grammar/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/types-grammar/ch1.md):

- **Octal literals** (e.g., `010`) are disallowed to prevent confusion with decimal numbers
- **`with` statements** are prohibited to eliminate dynamic scope and improve variable resolution predictability
- **`eval`** cannot introduce new variables into the surrounding scope

```javascript
"use strict";

// SyntaxError: Octal literals are not allowed
var num = 010;

// SyntaxError: Strict mode code may not include a with statement
with (Math) {
  console.log(PI);
}

```

## How to Enable Strict Mode in JavaScript

Strict mode can be applied at two scopes according to the source files:

**Script-wide strict mode**: Place `"use strict";` (or `'use strict';`) at the very beginning of a file, before any other statements.

**Function-level strict mode**: Place the pragma as the first line within a function body to enable strict mode only for that function's scope.

```javascript
// Non-strict code here

function strictFunction() {
  "use strict";
  // Strict mode applies only here
  undeclared = 1; // ReferenceError
}

// Non-strict code continues

```

As documented in [`types-grammar/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/types-grammar/ch1.md), the pragma must use exact syntax—back-ticks or other variations will not activate strict mode.

## Summary

- **Strict mode in JavaScript** is an opt-in ES5 feature enabled by `"use strict";` that applies stricter parsing and runtime semantics to code.
- It **prevents accidental global variables** by throwing ReferenceErrors when assigning to undeclared identifiers, as documented in [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md).
- It **secures the `this` binding** by defaulting to `undefined` instead of the global object, preventing accidental global mutations ([`objects-classes/ch4.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/objects-classes/ch4.md)).
- It **eliminates silent failures** on property assignments, `delete` operations, and duplicate parameter names by converting them into explicit errors ([`types-grammar/ch2.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/types-grammar/ch2.md), [`objects-classes/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/objects-classes/ch1.md)).
- It **disables problematic features** like `with`, octal literals, and certain `eval` behaviors that complicate optimization and security ([`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md)).

## Frequently Asked Questions

### What happens if I forget to declare a variable in strict mode?

In strict mode, assigning a value to a variable without declaring it with `var`, `let`, or `const` throws a **ReferenceError** immediately. According to [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md), this prevents the creation of accidental global variables that could pollute the global namespace and cause hard-to-debug issues in larger applications.

### Does strict mode affect the performance of my JavaScript code?

Yes, strict mode can improve performance. Because strict mode eliminates dynamic scoping via `with` and guarantees that variables must be declared before use, JavaScript engines can apply more aggressive optimizations. As noted in the source analysis, the engine can make stronger assumptions about variable resolution and object structure, leading to faster execution and better memory usage.

### Can I use strict mode in just part of my code?

Yes, strict mode can be enabled at the function level. By placing `"use strict";` as the first statement inside a function body, you enable strict mode only for that specific function's scope while leaving the surrounding code in non-strict mode. This is documented in [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md) and allows for gradual migration of legacy codebases to stricter standards.

### What is the difference between sloppy mode and strict mode?

"Sloppy mode" is the informal term for non-strict JavaScript, where the engine tolerates legacy behaviors like automatic global creation, silent failures on property assignments, and `this` defaulting to the global object. Strict mode, as implemented in ES5 and documented throughout the *You-Dont-Know-JS* repository, converts these silent failures into thrown errors, disables problematic features like `with` and octal literals, and defaults `this` to `undefined` in simple function calls.