JavaScript
Explica cómo strict mode convierte comportamientos silenciosos en errores, cambia this y arguments y restringe sintaxis ambigua en scripts y funciones.
Strict mode aplica reglas más rigurosas que convierten ciertos comportamientos silenciosos o ambiguos en errores.
"use strict";
undeclaredValue = 10;
// ReferenceErrorLa directiva debe aparecer al inicio del script, dentro del directive prologue.
"use strict";
const value = 10;Puede haber comentarios antes, pero no una sentencia que termine el prologue.
console.log("start");
"use strict";Aquí el string es una expresión normal y no activa strict mode para el script.
function calculate() {
"use strict";
return this;
}Afecta esa función y el código definido bajo su contexto estricto.
No es necesario activar todo el archivo para probar una función antigua de forma aislada.
export function calculate() {
// Strict mode automático.
}El código de módulos ECMAScript se ejecuta en strict mode sin escribir la directiva.
En proyectos modernos con import y export, agregar "use strict" en cada archivo normalmente es redundante.
class Counter {
increment() {
// Código estricto.
}
}Todas las partes de una declaración o expresión de clase utilizan semántica estricta.
En un script clásico no estricto, una asignación a un nombre no resuelto podía crear una propiedad global.
function saveName(name) {
userName = name;
}Con strict mode:
"use strict";
function saveName(name) {
userName = name;
// ReferenceError
}Esto detecta errores tipográficos cerca del origen.
const settings = Object.freeze({
theme: "dark",
});En código estricto:
"use strict";
settings.theme = "light";
// TypeErrorTambién puede lanzar al:
Sin strict mode, algunas operaciones podrían fallar sin cambiar nada y sin lanzar, haciendo más difícil detectar el bug.
function readThis() {
"use strict";
return this;
}
readThis(); // undefinedEn código no estricto, una llamada simple podía sustituir this por el objeto global.
Strict mode conserva undefined, lo que evita que una función modifique el global accidentalmente.
function setName(name) {
"use strict";
this.name = name;
}
setName("Nicolás");
// TypeError en lugar de escribir globalThis.name.function readThis() {
"use strict";
return this;
}readThis.call(null); // null
readThis.call(undefined); // undefined
readThis.call(10); // 10En funciones no estrictas, null y undefined podían convertirse al global y los primitivos envolverse en objetos.
Código no estricto tradicional:
function example(value) {
value = 20;
console.log(arguments[0]);
}Podía mostrar 20 porque el parámetro y arguments[0] estaban enlazados.
En strict mode:
function example(value) {
"use strict";
value = 20;
console.log(arguments[0]);
}
example(10); // 10Cambiar uno no cambia automáticamente el otro.
En código moderno, rest parameters expresan mejor listas de argumentos.
function example(value, value) {
"use strict";
}Produce SyntaxError.
Las funciones con parámetros no simples —defaults, rest o destructuring— ya tienen restricciones propias y no pueden contener una directiva "use strict" en su cuerpo.
function example(value = 0) {
"use strict";
// SyntaxError
}Si necesitas strict mode, utiliza un módulo o coloca la función dentro de un contexto estricto exterior.
"use strict";
with (settings) {
console.log(theme);
}
// SyntaxErrorwith vuelve ambigua la resolución de nombres y dificulta optimización y lectura. El código moderno debe usar acceso explícito.
console.log(settings.theme);"use strict";
delete user;
// SyntaxErrordelete trabaja con propiedades, no con bindings léxicos.
delete object.user;Esta operación puede ser válida si la propiedad es configurable.
Strict mode prohíbe ciertas formas octales antiguas y escapes heredados ambiguos.
"use strict";
const value = 010;
// SyntaxErrorLa sintaxis moderna explícita es:
const value = 0o10;"use strict";
eval("var hidden = 10");
console.log(hidden);
// ReferenceErrorLas declaraciones creadas dentro del eval estricto no se filtran al scope exterior de la misma forma que podían hacerlo en código no estricto.
Aun así, evita eval salvo necesidades muy específicas. Strict mode no elimina sus riesgos de claridad, seguridad y optimización.
Strict mode reserva ciertos identificadores relacionados con características futuras o sintaxis del lenguaje.
No necesitas memorizar la lista para trabajar normalmente. Linters y parsers modernos detectan estas construcciones.
"use strict";
let value = 10;
value = "ten";Sigue siendo válido. Strict mode no impide que una variable reciba valores de tipos diferentes.
Tampoco valida respuestas de APIs ni contratos de objetos.
Strict mode reduce comportamientos problemáticos, pero no aísla código ni evita:
La seguridad requiere controles del entorno y diseño de datos.
Reglas menos ambiguas permiten que motores y analizadores razonen mejor sobre el código.
El beneficio principal para quien programa es la corrección: errores que antes podían pasar silenciosamente ahora aparecen cerca de su origen.
No dependas de promesas genéricas de rendimiento; escribe código claro y mide rutas críticas.
En una aplicación basada en módulos:
import { createOrder } from "./orders.js";Ya estás en strict mode.
En scripts antiguos incrustados directamente:
<script src="legacy.js"></script>la directiva puede seguir siendo relevante.
Al migrar código antiguo, activar strict mode puede revelar errores que antes eran silenciosos. Corrígelos; no retires la directiva solo para esconderlos.
"use strict" después de otra sentencia.this como undefined.¿Por qué esta directiva no funciona?
function example(value = 0) {
"use strict";
return value;
}La función tiene una lista de parámetros no simple por el valor predeterminado. No puede contener una directiva use strict en su cuerpo. Debe ejecutarse dentro de un módulo o contexto estricto exterior.
Diseño de código confiable reúne las prácticas que reducen estados inválidos y hacen que los fallos sean más fáciles de detectar y manejar.