JavaScript
Modo estricto

Sintaxis

• 'uso estricto';
• "uso estricto";
• `uso estricto`;

Observaciones

Para guiones completos

El modo estricto se puede aplicar a secuencias de comandos completas colocando la declaración "use strict"; antes de cualquier otra declaración.

"use strict";
// strict mode now applies for the rest of the script

El modo estricto solo se habilita en los scripts en los que se define "use strict" . Puede combinar scripts con y sin modo estricto, porque el estado estricto no se comparte entre diferentes scripts.

Para funciones

El modo estricto también se puede aplicar a funciones individuales al anteponer el "use strict"; Declaración al comienzo de la declaración de función.

function strict() {
   "use strict";
   // strict mode now applies to the rest of this function
   var innerFunction = function () {
     // strict mode also applies here
   };
}

function notStrict() {
  // but not here
}

El modo estricto también se aplicará a cualquier función de ámbito interno.

Cambios en propiedades globales

En un ámbito de modo no estricto, cuando una variable se asigna sin inicializarse con la palabra clave var , const o let , se declara automáticamente en el ámbito global:

a = 12;
console.log(a); // 12

Sin embargo, en modo estricto, cualquier acceso a una variable no declarada generará un error de referencia:

"use strict";
a = 12; // ReferenceError: a is not defined
console.log(a);

Esto es útil porque JavaScript tiene una serie de eventos posibles que a veces son inesperados. En el modo no estricto, estos eventos a menudo llevan a los desarrolladores a creer que son errores o comportamiento inesperado, por lo que al habilitar el modo estricto, cualquier error que se genere les obliga a saber exactamente qué se está haciendo.

"use strict";
                       // Assuming a global variable mistypedVariable exists
mistypedVaraible = 17; // this line throws a ReferenceError due to the 
                       // misspelling of variable

Este código en modo estricto muestra un posible escenario: arroja un error de referencia que apunta al número de línea de la asignación, lo que permite al desarrollador detectar inmediatamente el error en el nombre de la variable.

En no estricto modo, además del hecho de que ningún error es lanzada y la cesión se realiza con éxito, el mistypedVaraible será declarado automáticamente en el ámbito global como una variable global. Esto implica que el desarrollador debe buscar manualmente esta asignación específica en el código.

Además, al forzar la declaración de variables, el desarrollador no puede declarar accidentalmente variables globales dentro de las funciones. En modo no estricto:

function foo() { 
   a = "bar"; // variable is automatically declared in the global scope
}
foo();
console.log(a); // >> bar

En modo estricto, es necesario declarar explícitamente la variable:

function strict_scope() { 
   "use strict";
   var a = "bar"; // variable is local
}
strict_scope();
console.log(a); // >> "ReferenceError: a is not defined"

La variable también se puede declarar fuera y después de una función, lo que permite que se use, por ejemplo, en el ámbito global:

function strict_scope() { 
   "use strict";
   a = "bar"; // variable is global
}
var a;
strict_scope();
console.log(a); // >> bar

Cambios en las propiedades

El modo estricto también evita que elimines las propiedades no recuperables.

"use strict";
delete Object.prototype; // throws a TypeError

La declaración anterior simplemente se ignoraría si no usa el modo estricto, sin embargo, ahora sabe por qué no se ejecuta como se esperaba.

También le impide extender una propiedad no extensible.

var myObject = {name: "My Name"}
Object.preventExtensions(myObject);

function setAge() {
    myObject.age = 25;   // No errors
}

function setAge() {
    "use strict";
    myObject.age = 25;  // TypeError: can't define property "age": Object is not extensible
}

Comportamiento de la lista de argumentos de una función.

arguments objeto se comportan diferente en modo estricto y no estricto . En el modo no estricto , el objeto argument reflejará los cambios en el valor de los parámetros que están presentes, sin embargo, en el modo estricto , cualquier cambio en el valor del parámetro no se reflejará en el objeto argument .

function add(a, b){
    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 5,10
}

add(1, 2);

Para el código anterior, el objeto de arguments se cambia cuando cambiamos el valor de los parámetros. Sin embargo, para el modo estricto , no se reflejará lo mismo.

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // Prints : 1,2

    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // Prints : 1,2
}

Vale la pena señalar que, si alguno de los parámetros undefined está undefined , y tratamos de cambiar el valor del parámetro en modo estricto o no estricto , el objeto de arguments permanece sin cambios.

Modo estricto

function add(a, b) {
    'use strict';

    console.log(arguments[0], arguments[1]); // undefined,undefined 
                                             // 1,undefined
    a = 5, b = 10;

    console.log(arguments[0], arguments[1]); // undefined,undefined
                                             // 1, undefined
}
add();
// undefined,undefined 
// undefined,undefined

add(1)
// 1, undefined
// 1, undefined

Modo no estricto

function add(a,b) {

    console.log(arguments[0],arguments[1]);

    a = 5, b = 10;

    console.log(arguments[0],arguments[1]);
}
add();
// undefined,undefined 
// undefined,undefined

add(1);
// 1, undefined
// 5, undefined

Parámetros duplicados

El modo estricto no le permite usar nombres de parámetros de función duplicados.

function foo(bar, bar) {}  // No error. bar is set to the final argument when called

"use strict";
function foo(bar, bar) {}; // SyntaxError: duplicate formal argument bar

Función de alcance en modo estricto

En el modo estricto, las funciones declaradas en un bloque local son inaccesibles fuera del bloque.

"use strict";
{
  f(); // 'hi'
  function f() {console.log('hi');}
}
f(); // ReferenceError: f is not defined

En cuanto al alcance, las declaraciones de funciones en modo estricto tienen el mismo tipo de enlace que let o const .

Listas de parámetros no simples

function a(x = 5) {
  "use strict";
}

JavaScript no es válido y lanzará un SyntaxError porque no puede usar la directiva "use strict" en una función con una lista de parámetros no simples como la anterior: asignación predeterminada x = 5

Los parámetros no simples incluyen:

• Asignación predeterminada

function a(x = 1) {
  "use strict";
}

• Destruccion

function a({ x }) {
  "use strict";
}

• Resto params

function a(...args) {
  "use strict";
}