JavaScript sigue siendo uno de los idiomas de programación más utilizados en la web, potenciando todo desde formas interactivas simples hasta aplicaciones complejas de una sola página. A medida que los proyectos crecen en tamaño y los miembros del equipo aumentan, la necesidad de un código fiable y predecible se vuelve primordial. Aquí es donde el modo estricto de JavaScript — una característica introducida en ECMAScript 5— se convierte en un error estricto, y permite que los desarrolladores opten por una variante restringida del lenguaje.

¿Qué es el modo más estricto?

El modo Strict es una manera de elegir un subconjunto más disciplinado de JavaScript. Cuando está habilitado, el motor JavaScript funciona bajo un conjunto de restricciones que eliminan algunas de las características más propensas al error del lenguaje. La idea detrás del modo estricto es proporcionar a los desarrolladores retroalimentación anterior sobre problemas potenciales. Por ejemplo, en modo no restringido (a menudo llamado "modo de solución) y establecer un modo estricto.

ECMAScript 5 introdujo el modo estricto en 2009 como una manera de evolucionar el lenguaje sin romper la compatibilidad atrasada. Los desarrolladores podrían optar por el comportamiento nuevo y más estricto simplemente añadiendo en la parte superior de un script o función. Desde entonces, el modo estricto se ha convertido en una práctica recomendada en muchos guías de estilo y se aplica automáticamente en construcciones modernas de JavaScript como módulos de ES (import/export) y cuerpos de clase.

Cómo Habilitar el Modo de Estricto

El modo estricto de habilitación es directo: insertas la cadena literal (o ]) al principio de un script o función. Esta directiva no es una declaración sino un pragma que dice al motor que pare el código posterior en modo estricto. Se puede aplicar en dos ámbitos: globalmente (para un script completo) o localmente (para una función única).

Modo de Strict de script-Level

Para habilitar el modo estricto para un archivo JavaScript completo o en línea bloque, coloque como la primera línea del script (antes de cualquier otra declaración). Por ejemplo:

// script.js
'use strict';

var x = 10;
console.log(x); // works normally

// Attempting to use undeclared variables throws an error
y = 20; // ReferenceError: y is not defined

Cuando se aplica globalmente, el modo estricto afecta todo el código en ese archivo de script. Si concatenado múltiples scripts, sólo los que comienzan con funcionarán en modo estricto. Es importante señalar que un script de modo estricto no puede mezclarse con código no-stricto en el mismo archivo a menos que utilice el análisis de nivel de función.

Modo de trabajo-dividual

También puede habilitar el modo estricto dentro de una función específica, dejando el resto del script en modo descuidado. Esto es útil cuando migra gradualmente una base de código o cuando desea una comprobación estricta sólo para ciertas funciones. Lugar en la parte superior del cuerpo de la función, antes de cualquier otra declaración:

function strictFunction() {
 'use strict';
 // Inside this function, strict mode applies
 var a = 1;
 b = 2; // ReferenceError: b is not defined
}

function sloppyFunction() {
 // Outside strictFunction, sloppy mode still applies
 c = 3; // creates global variable c
}

El modo estricto de nivel de función sólo se aplica al código propio de la función, no a ninguna función anidada (a menos que también declaren ). Sin embargo, en la práctica, es común establecer un modo estricto a nivel de archivo para la consistencia.

Módulos y clases

Con el advenimiento de ES6 (ES2015), los módulos y clases introducidos con JavaScript. Ambos se encuentran automáticamente en modo estricto por defecto. Por lo tanto, si escribe su código usando / sintaxis o define una , no necesita añadir —modo de restricción se aplica automáticamente. Por ejemplo:

// module.js (no 'use strict' needed)
export function add(a, b) {
 // strict mode is active here
 return a + b;
}

// class definition (strict mode active)
class MyClass {
 constructor(value) {
 this.value = value;
 }
}

Esta aplicación automática hace que el código en módulos y clases sea inherentemente más seguro y más fácil de razonar.

Beneficios clave de usar el modo estricto

Modo de rítmica ofrece una serie de beneficios que mejora directamente la calidad de código, seguridad y experiencia de desarrollador. Vamos a examinar cada beneficio en detalle.

Previene las variables globales accidentales

En modo no-stricto, asignar un valor a una variable no declarada crea automáticamente una propiedad en el objeto global (] en los navegadores en Node.js). Esto puede suceder fácilmente debido a errores tipográficos o declaraciones olvidadas, contaminando el espacio de nombres global y causando errores sutiles. El modo más estricto hace que esto sea imposible al lanzar un ejemplo.

// Non-strict: silently creates global variable
function setup() {
 developer = "Alice"; // accidentally global
}

// Strict: throws ReferenceError
function setup() {
 'use strict';
 developer = "Alice"; // ReferenceError: developer is not defined
}

Esta fuerza de ejecución desarrolla variables con , , o , reduciendo errores relacionados con el alcance.

Elimina los errores silenciosos

Este error es a menudo perdonador cuando las operaciones fallan en silencio. Por ejemplo, asignar a una propiedad sólo lectura (como o un objeto congelado) simplemente no hace nada en modo descuidado. En modo estricto, tales asignaciones lanzan un . De manera similar, los intentos de eliminar propiedades indelebles (por ejemplo, ) arrojan un error en lugar de retorno silencio [FLT]

// Non-strict: assignment silently fails
var obj = Object.freeze({name: "Bob"});
obj.name = "Charlie"; // silently ignored

// Strict: TypeError thrown
'use strict';
var obj = Object.freeze({name: "Bob"});
obj.name = "Charlie"; // TypeError: Cannot assign to read-only property 'name'

Previene los nombres de parámetros duplicados

En modo no restringido, las funciones pueden tener nombres de parámetro duplicados, que pueden conducir a comportamiento confuso (el último duplicado sobrescribe los anteriores). Modo de tirada prohíbe esto, lanzando un a la par. Por ejemplo:

// Non-strict: allowed
function sum(a, a, c) {
 return a + a + c; // a equals the second argument passed
}

// Strict: SyntaxError
'use strict';
function sum(a, a, c) { // SyntaxError: Duplicate parameter name not allowed in strict mode
 return a + a + c;
}

Esta restricción ayuda a prevenir la sobreescritura accidental de parámetros, haciendo que las firmas de funciones sean más claras y menos propensas al error.

Restricciones de la Declaración

La declaración se ha considerado desde hace mucho tiempo dañina porque crea ambigüedad sobre resolución variable y degrada el rendimiento. Modo estricto elimina completamente la declaración , lanzando un en tiempo de compilación. Esta eliminación alienta a los desarrolladores a utilizar patrones más predecibles, como la desestructuración o el acceso explícito de propiedad.

Hace más segura

En modo no restringido, puede introducir nuevas variables en el ámbito circundante, lo que lleva a efectos secundarios impredecibles. El modo estricto cambia el comportamiento de para que crea variables sólo dentro del código eval en sí mismo, no se filtran en el contexto de cierre. Esto hace que el código sea más fácil de razonar y previene la contaminación accidental del alcance.

// Non-strict: eval creates variable in outer scope
var x = 1;
eval("var x = 2;");
console.log(x); // 2

// Strict: eval has its own scope
'use strict';
var x = 1;
eval("var x = 2;");
console.log(x); // 1

Prohibiciones de las Literales Numéricos Octal

Históricamente, JavaScript interpretó números con un cero líder (por ejemplo, ) como octal (base 8). Este comportamiento a menudo causó confusión y errores, especialmente cuando se trata de cadenas como "010" siendo analizado como números. Modo estricto prohíbe los literales numéricos octal (excepto para el ES6+ prefijo) y arroja un [LT]

// Non-strict: 010 means octal 8
console.log(010); // 8

// Strict: SyntaxError
'use strict';
console.log(010); // SyntaxError: Octal literals are not allowed in strict mode

Distribuciones Eliminar Variables de la Placa

En modo no restringido, puede intentar eliminar variables o declaraciones de funciones, pero la operación falla silenciosamente (] devuelve ). El modo más estricto lanza un si intenta eliminar una variable, función o parámetro de función simple. Esto evita intentos accidentales de eliminar cosas que no se pueden borrar, y aclara la intención del desarrollador.

// Non-strict: attempt silently fails
var a = 1;
delete a; // false; a still exists

// Strict: SyntaxError
'use strict';
var a = 1;
delete a; // SyntaxError: Delete of an unqualified identifier in strict mode

Mejoras adicionales de seguridad y rendimiento

Más allá de las restricciones específicas, el modo estricto permite que los motores JavaScript realicen ciertas optimizaciones que son imposibles de otra manera. Debido a que el modo estricto elimina algunos comportamientos dinámicos (como la declaración y los globales implícitos), el motor puede predecir mejor cómo se utilizarán las variables, lo que llevó a una ejecución más rápida en algunos casos. Además, el modo estricto desactiva la propiedad y la apiltro permitiendo ciertos riesgos históricos.

Ejemplos prácticos del modo más estricto en acción

Para solidificar el entendimiento, paseemos por una serie de ejemplos que contrastan el modo descuidado con el modo estricto. Estos demuestran el modo estricto de retroalimentación inmediata proporciona.

Ejemplo 1: Asignación variable no declarada

// sloppy.js
function userInfo() {
 name = "John"; // silently creates global 'name'
}
userInfo();
console.log(window.name); // "John" (in browsers)

// strict.js
'use strict';
function userInfo() {
 name = "John"; // ReferenceError: name is not defined
}
userInfo();

Sin un modo estricto, un simple tipo como en lugar de puede contaminar el alcance global. Con un modo estricto, el error se detecta al instante.

Ejemplo 2: Asignación a una propiedad global sólo lectura

// sloppy mode
undefined = 5; // silently fails (undefined remains undefined)
NaN = 6; // silently fails
console.log(undefined, NaN); // undefined, NaN

// strict mode
'use strict';
undefined = 5; // TypeError: Cannot assign to read-only property 'undefined' of object '#<Window>'
NaN = 6; // TypeError

El modo más estricto evita la sobreescritura accidental de las constantes globales que nunca deben cambiar, ayudando a preservar la integridad del entorno de tiempo de ejecución.

Ejemplo 3: Nombres de propiedad de objetos duplicados

En modo estricto, los nombres de propiedades duplicados en objetos literales causan un . En modo descuidado, el último gana. Esto es especialmente útil para detectar errores al editar objetos de configuración o al copiar código.

// sloppy: works, last value wins
var config = {
 host: "example.com",
 host: "backup.com" // no error
};
console.log(config.host); // "backup.com"

// strict: SyntaxError
'use strict';
var config = {
 host: "example.com",
 host: "backup.com" // SyntaxError: Duplicate data property in object literal not allowed in strict mode
};

Pitfalls comunes y migrando al modo más estricto

Si bien el modo estricto trae muchos beneficios, la migración de una gran base de código existente puede presentar desafíos. Algunas pautas antiguas que se consideraron aceptables en ES3/5 pueden ahora fracasar.

  • cesión variable no declarada: El código que se basa en los globales implícitos debe actualizarse para declarar variables.
  • Usando declaraciones : Estas deben ser refactorizadas en accesos explícitos a la propiedad.
  • ] literales octtales : Reemplazar con o decimal .
  • Adherirse : Esto es desagrado; utilizar expresiones de función nombradas en su lugar.
  • Nombres de parámetro duplicados: Debe ser removido o renombrado.
  • Usando sobre variables o funciones: Esa operación está prohibida.

El proceso de migración es a menudo incremental. Puede habilitar la función de modo estricto mediante la función pragma dentro de funciones, probar a fondo y luego activarlo globalmente una vez que usted esté seguro. Herramientas como ESLint con su regla pueden ayudar a identificar las violaciones automáticamente. Además, el uso de módulos de ES o clases automáticamente le da un comportamiento estricto de modo, por lo que migrar a la sintaxis moderna es un camino natural hacia un camino estricto.

También vale la pena señalar que el modo estricto no es un asesino de rendimiento. De hecho, como se mencionó, algunos motores pueden optimizar mejor el código de modo estricto. El cheque inicial de tiempo de ejecución para la directiva es insignificante, y la claridad de código general y la seguridad superan con creces cualquier costo marginal.

Conclusión y prácticas óptimas

El modo estricto de JavaScript es una herramienta poderosa para escribir código más robusto, sostenible y seguro. Al optar por este subconjunto restringido del lenguaje, los desarrolladores obtienen detección temprana de errores comunes, evitan construcciones peligrosas y se benefician de un mejor rendimiento en muchos casos. El modo estricto de habilitar es tan simple como añadir al comienzo de un script o función, y es automáticamente activo en módulos y clases de errores silencio.

Para cualquier proyecto, ya sea nuevo o legado, adoptar un modo estricto debe considerarse una mejor práctica. Comience por utilizar un interintor para identificar las violaciones, fijarlas gradualmente y probar con frecuencia. Las herramientas y marcos de JavaScript modernos a menudo asumen un modo estricto (o lo hacen), así que alinearse con esa convención garantiza la compatibilidad y consistencia. Al abrazar el modo estricto, se une a la comunidad de JavaScript más amplia para priorizar la calidad y seguridad del código.

Para profundizar, consulte la documentación MDN en modo estricto] para una lista completa de restricciones y ejemplos. Para el contexto histórico, la especificación ECMAScript explica las reglas formales. Adicionalmente, la ESLint strict rule proporciona una manera automatizada de hacer un uso estricto.