How Strict Mode Changes JavaScript Runtime Evaluation

JavaScript’s strict mode, invoked by adding "use strict"; at the top of a script or function, modifies the language’s runtime evaluation semantics to make code more robust, secure, and performant. Instead of failing silently when encountering problematic patterns, the JavaScript engine alters variable scoping, function execution context, property assignments, and evaluation mechanics to actively throw runtime exceptions and prevent error-prone behaviors.

Elimination of Silent Assignment Failures

In non-strict (sloppy) mode, certain illegal operations fail quietly without stopping execution. Strict mode converts these silent failures into explicit runtime TypeError exceptions:

• Undeclared Variables: Assigning a value to an undeclared variable throws a ReferenceError instead of implicitly creating a global variable.
• Non-Writable Properties: Attempting to assign a value to a non-writable global variable (such as undefined or NaN), a read-only property, or an accessor-only (getter-only) property throws a TypeError.
• Non-Extensible Objects: Attempting to add new properties to an object configured with Object.preventExtensions(), Object.seal(), or Object.freeze() throws a TypeError.
• Deleting Non-Configurable Properties: Attempting to use the delete operator on non-configurable object properties throws a TypeError instead of returning false.

Contextual this Value Changes

Strict mode changes how the default this context is evaluated during standard function execution:

• In sloppy mode, invoking a standalone function without a specified context automatically binds this to the global object (window in browsers or global in Node.js).
• In strict mode, this remains undefined if it is not explicitly bound via invocation context, call(), apply(), or bind().
• When primitive values (such as strings, booleans, or numbers) are passed as this using call or apply, strict mode preserves the raw primitive rather than automatically boxing it into an Object instance.

eval Scope Isolation

Strict mode significantly alters how the eval() function evaluates code at runtime:

• In sloppy mode, code executed via eval() can introduce new variables and functions directly into the enclosing lexical scope.
• In strict mode, eval() creates its own private lexical scope. Variables and functions declared inside the evaluated string exist only during the execution of that specific eval() statement and do not leak into the containing scope.

Decoupling of the arguments Object

Strict mode separates the synchronization between named function parameters and the indexed arguments object:

• In sloppy mode, modifying an element within arguments[i] dynamically updates the corresponding named parameter in the function signature, and vice versa.
• In strict mode, arguments acts as a static snapshot of the arguments passed during invocation. Changing a named parameter does not modify the corresponding value in arguments, nor does modifying arguments alter the named parameter.
• Accessing arguments.callee or arguments.caller is completely restricted and throws a TypeError during evaluation.

Syntax and Variable Restrictions

Strict mode enforces immediate runtime errors on patterns that make static analysis and optimization difficult for the JavaScript engine:

• Duplicate Parameter Names: Declaring a function with identical parameter names (for example, function sum(a, a, b)) throws a syntax error prior to execution.
• The with Statement: The with statement is entirely banned because it makes variable resolution ambiguous at runtime; encountering it triggers an immediate syntax error.
• Legacy Octal Literals: Prefixed numeric literals using a leading zero (e.g., 0644) are forbidden to avoid ambiguity, requiring explicit octal prefixes instead (e.g., 0o644).