What does 'use strict' do?

Q: What does 'use strict' do?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every sloppy-vs-strict contrast below was actually run in Node — not recited from documentation. ## 1. Why This Even Matters — A Story First Sloppy mode is like a lenient proofreader who quietly fixes your typos without telling you — convenient in the moment, but it means real mistakes slip through unflagged. Strict mode is a proofreader who stops and flags every questionable thing instead of guessing your intent. 'use strict' switches which proofreader is watching your code. ## 2. The Core Idea 📌 **Interview term:** `'use strict'` is a directive placed as the first statement in a file or function body that opts into a stricter execution mode — several silent, error-prone behaviors become real, immediately thrown errors instead. ## 3. Verified: undeclar

The problem

Question presented to candidate: "What does adding 'use strict' at the top of a file actually change about how the code runs? Give me two or three concrete behavior differences, not just 'it makes errors stricter.'"

What a strong answer should cover:

📌 Interview term: 'use strict' — a directive (a special string literal, not a comment) that opts a script or function into a stricter variant of JavaScript's semantics, turning several silent failures/quirky behaviors into real, thrown errors.
📌 Interview term: undeclared-variable throw — verified directly: in sloppy mode, assigning to a variable that was never declared silently creates a global variable; in strict mode, the identical assignment throws a real ReferenceError.
📌 Interview term: this in a plain function call — verified directly: calling a plain (non-method) function in sloppy mode gives this the global-ish object; in strict mode, this is genuinely undefined — a real, observable difference that prevents accidentally mutating global state through a mis-bound this.
📌 Interview term: silent-failure-to-throw conversion — verified directly: assigning to a property of a frozen object silently no-ops in sloppy mode (no error, and the value just doesn't change); in strict mode, the identical assignment genuinely throws a real TypeError.
A precise answer names that classes and ES modules are implicitly strict — no directive needed, verified directly — while plain <script> tags and CommonJS modules are sloppy by default unless the directive is explicitly added.

Clarifying questions expected:

None — this is a definitional/technical question; naming 2-3 concrete, verified behavior differences (not a vague "it's safer") is the strong signal.

Code / implementation expected: Yes — demonstrating at least one sloppy-vs-strict contrast directly (undeclared globals or the frozen-object throw) proves real, not memorized, understanding.

strict-mode

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals interviews. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every sloppy-vs-strict contrast below was actually run in Node — not recited from documentation.

1. Why This Even Matters — A Story First

Sloppy mode is like a lenient proofreader who quietly fixes your typos without telling you — convenient in the moment, but it means real mistakes slip through unflagged. Strict mode is a proofreader who stops and flags every questionable thing instead of guessing your intent. 'use strict' switches which proofreader is watching your code.

2. The Core Idea

📌 Interview term: 'use strict' is a directive placed as the first statement in a file or function body that opts into a stricter execution mode — several silent, error-pr

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal sloppy-vs-strict-mode behavior differences: undeclared globals, this, and frozen objects