JavaScript Strict Mode Use Strict Explained

JavaScript strict mode is a stricter way to parse and run JavaScript. It turns several silent mistakes into errors and changes a few confusing language behaviors.

You enable it in classic scripts with a directive string: "use strict".

How to Enable Strict Mode

Put the directive at the top of a script or function body, before any other statement. That placement matters because directive strings only count before normal code starts.

javascript

"use strict";
 
let score = 100;
console.log(score);

Comments can appear above the directive. A real statement cannot, because then the string is no longer treated as a directive.

You can also enable it for one function:

javascript

function calculateTotal(items) {
  "use strict";
  return items.length;
}

Only that function body is strict. Other functions are strict only if their own code is strict.

What Strict Mode Catches

Strict mode is useful because it makes common mistakes fail loudly.

javascript

"use strict";
 
score = 100;

This throws a ReferenceError because score was never declared. In non-strict scripts, that mistake can create a global variable.

Strict mode also catches writes to read-only properties:

javascript

"use strict";
 
const user = {};
Object.defineProperty(user, "id", { value: 1, writable: false });
user.id = 2;

The assignment throws a TypeError instead of failing silently.

Strict Mode Changes this

In a plain function call, strict mode leaves this as undefined.

javascript

function showThis() {
  "use strict";
  console.log(this);
}
 
showThis();

The output is undefined. In non-strict browser scripts, a plain function call can use the global object instead, which often causes accidental global mutations.

Where Strict Mode Is Automatic

Modern JavaScript turns on strict mode automatically in some places:

If you are writing modules, you do not need to add "use strict". If you are writing an older classic script, adding the directive is still useful.

Strict Mode Scope

Strict mode is lexical. That means it depends on where code is written, not who calls it.

javascript

"use strict";
 
function strictFunction() {
  return "strict";
}

This function is strict because it is written inside a strict script. But a separate non-strict function does not become strict just because strict code calls it.

There is also no directive that turns strict mode off inside a strict scope.

Should You Use Strict Mode?

For new classic script files, yes. It catches real mistakes and makes behavior easier to reason about.

For modules and classes, it is already active. For old legacy code, enable it carefully and test, because strict mode can expose mistakes that were previously ignored.

For broader consistency, see the JavaScript code style guide. You can also practice small strict-mode examples in Chrome DevTools.