¿Qué hace "usar estricto" en JavaScript, y cuál es el razonamiento detrás de esto?

7955

Recientemente, ejecuté parte de mi código JavaScript a través de JSLint de Crockford y me dio el siguiente error:

Problem at line 1 character 1: Missing "use strict" statement.

Al hacer algunas búsquedas, me di cuenta de que algunas personas agregan "use strict";en su código JavaScript. Una vez que agregué la declaración, el error dejó de aparecer. Desafortunadamente, Google no reveló gran parte de la historia detrás de esta declaración de cadena. Ciertamente, debe tener algo que ver con la forma en que el navegador interpreta JavaScript, pero no tengo idea de cuál sería el efecto.

Entonces, ¿de qué se "use strict";trata, qué implica y sigue siendo relevante?

¿Alguno de los navegadores actuales responde a la "use strict";cadena o es para uso futuro?

1
  • 19
    Las respuestas aquí son antiguas pero incorrectas. El principal razonamiento para el modo estricto no fue evitar errores de programación, fue hacer que JavaScript tenga un alcance léxico para que pueda ser analizable estáticamente:] 6/09/19 a las 11:40
5192

Este artículo sobre el modo estricto de Javascript puede interesarle: John Resig - Modo estricto de ECMAScript 5, JSON y más

Para citar algunas partes interesantes:

Strict Mode is a new feature in ECMAScript 5 that allows you to place a program, or a function, in a "strict" operating context. This strict context prevents certain actions from being taken and throws more exceptions.

Y:

Strict mode helps out in a couple ways:

  • It catches some common coding bloopers, throwing exceptions.
  • It prevents, or throws errors, when relatively "unsafe" actions are taken (such as gaining access to the global object).
  • It disables features that are confusing or poorly thought out.

También tenga en cuenta que puede aplicar el "modo estricto" a todo el archivo ... O puede usarlo solo para una función específica (aún citando el artículo de John Resig) :

// Non-strict code...

(function(){
  "use strict";

  // Define your library strictly...
})();

// Non-strict code...

Lo que podría ser útil si tiene que mezclar código antiguo y nuevo ;-)

Entonces, supongo que es un poco como el "use strict"que puedes usar en Perl (¿de ahí el nombre?) : Te ayuda a cometer menos errores, al detectar más cosas que podrían conducir a roturas.

El modo estricto ahora es compatible con todos los navegadores principales .

Dentro de los módulos ECMAScript nativos (con declaraciones importy export) y las clases ES6 , el modo estricto siempre está habilitado y no se puede deshabilitar.

0
1326

Es una nueva característica de ECMAScript 5. John Resig escribió un buen resumen de la misma.

Es solo una cadena que pones en tus archivos JavaScript (ya sea en la parte superior de tu archivo o dentro de una función) que se ve así:

"use strict";

Ponerlo en su código ahora no debería causar ningún problema con los navegadores actuales, ya que es solo una cadena. Puede causar problemas con su código en el futuro si su código viola el pragma. Por ejemplo, si actualmente tiene foo = "bar"sin definir fooprimero, su código comenzará a fallar ... lo cual es algo bueno en mi opinión.

0
739

La declaración "use strict"; indica al navegador que utilice el modo estricto, que es un conjunto de funciones de JavaScript reducido y más seguro.

Lista de características (no exhaustiva)

  1. No permite variables globales. (Detecta vardeclaraciones faltantes y errores tipográficos en nombres de variables)

  2. Las asignaciones fallidas silenciosas arrojarán error en modo estricto (asignación NaN = 5;)

  3. Los intentos de eliminar propiedades indelebles arrojarán ( delete Object.prototype)

  4. Requiere que todos los nombres de propiedad en un objeto literal sean únicos ( var x = {x1: "1", x1: "2"})

  5. Los nombres de los parámetros de función deben ser únicos ( function sum (x, x) {...})

  6. Prohíbe la sintaxis octal ( var x = 023;algunos desarrolladores asumen erróneamente que un cero precedente no hace nada para cambiar el número).

  7. Prohíbe la withpalabra clave

  8. eval en modo estricto no introduce nuevas variables

  9. Prohíbe eliminar nombres sin formato ( delete x;)

  10. Prohíbe la vinculación o cesión de los nombres evaly argumentsen cualquier forma

  11. El modo estricto no alias las propiedades del argumentsobjeto con los parámetros formales. (por ejemplo, en function sum (a,b) { return arguments[0] + b;}Esto funciona porque arguments[0]está vinculado a ay así sucesivamente).

  12. arguments.callee no es apoyado

[Ref: modo estricto , Mozilla Developer Network ]

1
  • 3
    El ejemplo de 11. no está claro, no está claro cuál es la diferencia en el modo estricto.
    RobG
    11 de marzo a las 23:36
442

Si la gente está preocupada por su uso use strict, valdría la pena consultar este artículo:

Compatibilidad con ECMAScript 5 'Modo estricto' en navegadores. ¿Qué significa esto?
NovoGeek.com - el weblog de Krishna

Habla sobre la compatibilidad con el navegador, pero lo que es más importante, cómo manejarlo de forma segura:

function isStrictMode(){
    return !this;
} 
/*
   returns false, since 'this' refers to global object and 
   '!this' becomes false
*/

function isStrictMode(){   
    "use strict";
    return !this;
} 
/* 
   returns true, since in strict mode the keyword 'this'
   does not refer to global object, unlike traditional JS. 
   So here, 'this' is 'undefined' and '!this' becomes true.
*/
0
230

Una palabra de advertencia, todos los programadores que se esfuerzan mucho: ¡aplicar "use strict"al código existente puede ser peligroso! Esta cosa no es una pegatina de cara feliz que te haga sentir bien y que puedas pegarle al código para hacerlo "mejor". Con el "use strict"pragma, el navegador arrojará repentinamente excepciones en lugares aleatorios que nunca antes arrojó solo porque en ese lugar estás haciendo algo que JavaScript predeterminado / suelto permite felizmente pero que el JavaScript estricto aborrece. Es posible que tenga infracciones de rigurosidad escondidas en llamadas poco utilizadas en su código que solo generarán una excepción cuando finalmente se ejecuten, por ejemplo, en el entorno de producción que usan sus clientes de pago.

Si va a dar el paso, es una buena idea aplicar "use strict"junto con pruebas unitarias integrales y una tarea de compilación JSHint estrictamente configurada que le dará cierta confianza en que no hay un rincón oscuro de su módulo que explote horriblemente solo porque usted he activado el modo estricto. O bien, aquí hay otra opción: simplemente no agregue "use strict"nada a su código heredado, probablemente sea más seguro de esa manera, honestamente. DEFINITIVAMENTE NO agregue "use strict"a ningún módulo que no sea de su propiedad o que no mantenga, como módulos de terceros.

Creo que aunque es un animal enjaulado mortal, "use strict"puede ser algo bueno, pero hay que hacerlo bien. El mejor momento para ser estricto es cuando su proyecto es totalmente nuevo y está comenzando desde cero. Configure JSHint/JSLintcon todas las advertencias y opciones ajustadas tan estrictamente como su equipo pueda soportar, obtenga un buen sistema de compilación / prueba / afirmación del día arreglado como Grunt+Karma+Chai, y solo ENTONCES comience a marcar todos sus nuevos módulos como "use strict". Esté preparado para solucionar muchos errores y advertencias molestos. Asegúrese de que todos comprendan la gravedad configurando la compilación en FALLO si se JSHint/JSLintproduce alguna infracción.

Mi proyecto no era un proyecto nuevo cuando lo adopté "use strict". Como resultado, mi IDE está lleno de marcas rojas porque no tengo la "use strict"mitad de mis módulos, y JSHint se queja de eso. Es un recordatorio para mí sobre qué refactorización debería hacer en el futuro. Mi objetivo es estar libre de marcas rojas debido a todas mis "use strict"declaraciones faltantes , pero eso es años de distancia.

0
209

El uso 'use strict';no mejora repentinamente su código.

El modo estricto de JavaScript es una característica de ECMAScript 5 . Puede habilitar el modo estricto declarando esto en la parte superior de su script / función.

'use strict';

Cuando un motor de JavaScript ve esta directiva , comenzará a interpretar el código en un modo especial. En este modo, los errores surgen cuando se detectan ciertas prácticas de codificación que podrían terminar siendo posibles errores (que es el razonamiento detrás del modo estricto).

Considere este ejemplo:

var a = 365;
var b = 030;

En su obsesión por alinear los literales numéricos, el desarrollador ha inicializado inadvertidamente una variable bcon un literal octal. El modo no estricto interpretará esto como un literal numérico con valor 24(en base 10). Sin embargo, el modo estricto arrojará un error.

Para obtener una lista no exhaustiva de especialidades en modo estricto, consulte esta respuesta .


¿Dónde debo usar 'use strict';?

  • En mi nueva aplicación JavaScript: ¡Por supuesto! El modo estricto se puede usar como denunciante cuando está haciendo algo estúpido con su código.

  • En mi código JavaScript existente : ¡ Probablemente no! Si su código JavaScript existente tiene declaraciones que están prohibidas en modo estricto, la aplicación simplemente se romperá. Si desea el modo estricto, debe estar preparado para depurar y corregir su código existente. Esta es la razón por la que el uso 'use strict';no mejora repentinamente su código .


¿Cómo utilizo el modo estricto?

  1. Inserte una 'use strict';declaración en la parte superior de su guión:

    // File: myscript.js
    
    'use strict';
    var a = 2;
    ....
    

    Tenga en cuenta que todo el contenido del archivo myscript.jsse interpretará en modo estricto.

  2. O inserte una 'use strict';declaración en la parte superior del cuerpo de su función:

    function doSomething() {
        'use strict';
        ...
    }
    

    Todo lo que esté en el ámbito léxico de la función doSomethingse interpretará en modo estricto. La palabra alcance léxico es importante aquí. Por ejemplo, si su código estricto llama a una función de una biblioteca que no es estricta , solo su código se ejecuta en modo estricto, y no la función llamada. Vea esta respuesta para una mejor explicación.


¿Qué cosas están prohibidas en modo estricto?

Encontré un buen artículo que describe varias cosas que están prohibidas en modo estricto (tenga en cuenta que esta no es una lista exclusiva):

Scope

Historically, JavaScript has been confused about how functions are scoped. Sometimes they seem to be statically scoped, but some features make them behave like they are dynamically scoped. This is confusing, making programs difficult to read and understand. Misunderstanding causes bugs. It also is a problem for performance. Static scoping would permit variable binding to happen at compile time, but the requirement for dynamic scope means the binding must be deferred to runtime, which comes with a significant performance penalty.

Strict mode requires that all variable binding be done statically. That means that the features that previously required dynamic binding must be eliminated or modified. Specifically, the with statement is eliminated, and the eval function’s ability to tamper with the environment of its caller is severely restricted.

One of the benefits of strict code is that tools like YUI Compressor can do a better job when processing it.

Implied Global Variables

JavaScript has implied global variables. If you do not explicitly declare a variable, a global variable is implicitly declared for you. This makes programming easier for beginners because they can neglect some of their basic housekeeping chores. But it makes the management of larger programs much more difficult and it significantly degrades reliability. So in strict mode, implied global variables are no longer created. You should explicitly declare all of your variables.

Global Leakage

There are a number of situations that could cause this to be bound to the global object. For example, if you forget to provide the new prefix when calling a constructor function, the constructor's this will be bound unexpectedly to the global object, so instead of initializing a new object, it will instead be silently tampering with global variables. In these situations, strict mode will instead bind this to undefined, which will cause the constructor to throw an exception instead, allowing the error to be detected much sooner.

Noisy Failure

JavaScript has always had read-only properties, but you could not create them yourself until ES5’s Object.createProperty function exposed that capability. If you attempted to assign a value to a read-only property, it would fail silently. The assignment would not change the property’s value, but your program would proceed as though it had. This is an integrity hazard that can cause programs to go into an inconsistent state. In strict mode, attempting to change a read-only property will throw an exception.

Octal

The octal (or base 8) representation of numbers was extremely useful when doing machine-level programming on machines whose word sizes were a multiple of 3. You needed octal when working with the CDC 6600 mainframe, which had a word size of 60 bits. If you could read octal, you could look at a word as 20 digits. Two digits represented the op code, and one digit identified one of 8 registers. During the slow transition from machine codes to high level languages, it was thought to be useful to provide octal forms in programming languages.

In C, an extremely unfortunate representation of octalness was selected: Leading zero. So in C, 0100 means 64, not 100, and 08 is an error, not 8. Even more unfortunately, this anachronism has been copied into nearly all modern languages, including JavaScript, where it is only used to create errors. It has no other purpose. So in strict mode, octal forms are no longer allowed.

Et cetera

The arguments pseudo array becomes a little bit more array-like in ES5. In strict mode, it loses its callee and caller properties. This makes it possible to pass your arguments to untrusted code without giving up a lot of confidential context. Also, the arguments property of functions is eliminated.

In strict mode, duplicate keys in a function literal will produce a syntax error. A function can’t have two parameters with the same name. A function can’t have a variable with the same name as one of its parameters. A function can’t delete its own variables. An attempt to delete a non-configurable property now throws an exception. Primitive values are not implicitly wrapped.


Palabras reservadas para futuras versiones de JavaScript

ECMAScript 5 agrega una lista de palabras reservadas. Si los usa como variables o argumentos, el modo estricto arrojará un error. Las palabras reservadas son:

implements, interface, let, package, private, protected, public, static, and yield


Otras lecturas

0
147

Recomiendo encarecidamente a todos los desarrolladores que comiencen a usar el modo estricto ahora. Hay suficientes navegadores que lo admiten, por lo que el modo estricto nos ayudará legítimamente a salvarnos de errores que ni siquiera sabíamos que estaban en su código.

Aparentemente, en la etapa inicial habrá errores que nunca antes habíamos encontrado. Para obtener el beneficio completo, debemos realizar las pruebas adecuadas después de cambiar al modo estricto para asegurarnos de haber capturado todo. Definitivamente no solo incluimos use strictnuestro código y asumimos que no hay errores. Entonces, la pérdida es que es hora de comenzar a usar esta característica de lenguaje increíblemente útil para escribir mejor código.

Por ejemplo,

var person = {
    name : 'xyz',
    position : 'abc',
    fullname : function () {  "use strict"; return this.name; }
};

JSLint es un depurador escrito por Douglas Crockford. Simplemente pegue su secuencia de comandos y escaneará rápidamente en busca de problemas y errores notables en su código.

0
101

Me gustaría ofrecer una respuesta algo más fundamentada que complemente las otras respuestas. Esperaba editar la respuesta más popular, pero fallé. Traté de hacerlo lo más completo y completo que pude.

Puede consultar la documentación de MDN para obtener más información.

"use strict" una directiva introducida en ECMAScript 5.

Las directivas son similares a las declaraciones, pero diferentes.

  • use strictno contiene palabras clave: la directiva es una declaración de expresión simple, que consta de un literal de cadena especial (entre comillas simples o dobles). Los motores de JavaScript, que no implementan ECMAScript 5, simplemente ven una declaración de expresión sin efectos secundarios. Se espera que las futuras versiones de los estándares ECMAScript se presenten usecomo una palabra clave real; por tanto, las citas quedarían obsoletas.
  • use strictsólo se puede utilizar al principio de un script o de una función, es decir, debe preceder a cualquier otra declaración (real). No tiene que ser la primera instrucción en un script de función: puede ir precedida de otras expresiones de declaración que consistan en cadenas literales (y las implementaciones de JavaScript pueden tratarlas como directivas específicas de implementación). Las declaraciones de cadenas literales, que siguen a una primera declaración real (en un script o función) son declaraciones de expresión simples. Los intérpretes no deben interpretarlos como directivas y no tienen ningún efecto.

La use strictdirectiva indica que el siguiente código (en un script o una función) es un código estricto. El código en el nivel más alto de un script (código que no está en una función) se considera código estricto cuando el script contiene una use strictdirectiva. El contenido de una función se considera código estricto cuando la función en sí está definida en un código estricto o cuando la función contiene una use strictdirectiva. El código que se pasa a un eval()método se considera código estricto cuando eval()se llama desde un código estricto o contiene la use strictdirectiva en sí.

El modo estricto de ECMAScript 5 es un subconjunto restringido del lenguaje JavaScript, que elimina los déficits relevantes del lenguaje y presenta una verificación de errores más estricta y una mayor seguridad. A continuación se enumeran las diferencias entre el modo estricto y el modo normal (de los cuales los tres primeros son particularmente importantes):

  • No puede utilizar la withinstrucción -en modo estricto.
  • En modo estricto, todas las variables deben declararse: si asigna un valor a un identificador que no ha sido declarado como variable, función, parámetro de función, parámetro de cláusula de captura o propiedad del global Object, obtendrá un ReferenceError. En modo normal, el identificador se declara implícitamente como una variable global (como una propiedad de lo global Object)
  • En modo estricto, la palabra clave thistiene el valor undefineden funciones que se invocaron como funciones (no como métodos). (En modo normal thissiempre apunta al global Object). Esta diferencia se puede utilizar para probar si una implementación admite el modo estricto:
var hasStrictMode = (function() { "use strict"; return this===undefined }());
  • Además, cuando se invoca una función con call()o applyen modo estricto, entonces thises exactamente el valor del primer argumento de la invocación call()o apply(). (En modo normal nully undefinedse reemplazan por Objectvalores globales y, que no son objetos, se convierten en objetos).

  • En modo estricto obtendrá un TypeError, cuando intente asignar a propiedades de solo lectura o definir nuevas propiedades para un objeto no extensible. (En modo normal, ambos simplemente fallan sin mensaje de error).

  • En modo estricto, al pasar código a eval(), no puede declarar o definir variables o funciones en el alcance de la persona que llama (como puede hacerlo en modo normal). En cambio, se crea un nuevo alcance eval()y las variables y funciones están dentro de ese alcance. Ese alcance se destruye después de que eval()finaliza la ejecución.
  • En modo estricto, el objeto-argumentos de una función contiene una copia estática de los valores, que se pasan a esa función. En el modo normal, el objeto-argumentos tiene un comportamiento algo "mágico": los elementos de la matriz y los parámetros de la función nombrada hacen referencia a ambos al mismo valor.
  • En el modo estricto, obtendrá un SyntaxErrorcuando al deleteoperador le sigue un identificador no calificado (una variable, función o parámetro de función). En el modo normal, la deleteexpresión no haría nada y se evalúa como false.
  • En modo estricto, obtendrá un TypeErrorcuando intente eliminar una propiedad no configurable. (En el modo normal, el intento simplemente falla y la deleteexpresión se evalúa como false).
  • En modo estricto se considera un error sintáctico cuando intenta definir varias propiedades con el mismo nombre para un objeto literal. (En modo normal no hay error).
  • En modo estricto se considera un error sintáctico cuando la declaración de una función tiene varios parámetros con el mismo nombre. (En modo normal no hay error).
  • En el modo estricto, los literales octales no están permitidos (estos son literales que comienzan con 0x. (En el modo normal, algunas implementaciones sí permiten literales octales).
  • En modo estricto, los identificadores evaly argumentsse tratan como palabras clave. No puede cambiar su valor, no puede asignarles un valor y no puede usarlos como nombres para variables, funciones, parámetros de función o identificadores de un bloque catch.
  • En el modo estricto hay más restricciones sobre las posibilidades de examinar la pila de llamadas. arguments.callery arguments.calleecausa una TypeErroren una función en modo estricto. Además, algunas propiedades de llamadas y argumentos de funciones en modo estricto provocan un error TypeErrorcuando intenta leerlas.
1
  • 4
    "En el modo estricto, los literales octales no están permitidos (estos son literales que comienzan con 0x ...)", los literales octales comienzan con un encabezado 0. 11/08/2016 a las 19:52
88

Mis dos centavos:

Uno de los objetivos del modo estricto es permitir una depuración más rápida de los problemas. Ayuda a los desarrolladores al lanzar una excepción cuando ocurren ciertas cosas incorrectas que pueden causar un comportamiento silencioso y extraño de su página web. En el momento en que lo usemos use strict, el código arrojará errores que ayudarán al desarrollador a solucionarlo por adelantado.

Algunas cosas importantes que he aprendido después de usar use strict:

Evita la declaración de variable global:

var tree1Data = { name: 'Banana Tree',age: 100,leafCount: 100000};

function Tree(typeOfTree) {
    var age;
    var leafCount;

    age = typeOfTree.age;
    leafCount = typeOfTree.leafCount;
    nameoftree = typeOfTree.name;
};

var tree1 = new Tree(tree1Data);
console.log(window);

Ahora, este código crea nameoftreeun alcance global al que se puede acceder usando window.nameoftree. Cuando implementamos use strictel código arrojaría error.

Uncaught ReferenceError: nameoftree is not defined

Sample

Elimina la withdeclaración:

withLas declaraciones no se pueden minimizar con herramientas como uglify-js . También están en desuso y se eliminaron de futuras versiones de JavaScript.

Sample

Evita los duplicados:

Cuando tenemos una propiedad duplicada, lanza una excepción

Uncaught SyntaxError: Duplicate data property in object literal not allowed in strict mode

"use strict";
var tree1Data = {
    name: 'Banana Tree',
    age: 100,
    leafCount: 100000,
    name:'Banana Tree'
};

Hay algunos más, pero necesito adquirir más conocimientos al respecto.

0
67

Si utiliza un navegador lanzado en el último año, lo más probable es que admita el modo estricto de JavaScript. Solo los navegadores más antiguos antes de que ECMAScript 5 se convirtiera en el estándar actual no lo admiten.

Las comillas alrededor del comando aseguran que el código también funcionará en navegadores más antiguos (aunque las cosas que generan un error de sintaxis en modo estricto generalmente solo harán que el script funcione mal de alguna manera difícil de detectar en esos navegadores más antiguos).

0
62

Al agregar "use strict";, los siguientes casos arrojarán un SyntaxError antes de que se ejecute el script:

  • Allanando el camino para futuras versiones de ECMAScript , utilizando una de las palabras clave recién reservados (en previsión de ECMAScript 6 ): implements, interface, let, package, private, protected, public, static, y yield.

  • Declaración de función en bloques

    if(a<b){ function f(){} }
    
  • Sintaxis octal

    var n = 023;
    
  • this apuntar al objeto global.

     function f() {
          "use strict";
          this.a = 1;
     };
     f(); 
    
  • Declarar dos veces el mismo nombre para un nombre de propiedad en un objeto literal

     {a: 1, b: 3, a: 7} 
    

    Este ya no es el caso en ECMAScript 6 ( error 1041128 ).

  • Declarar dos argumentos de función con el mismo nombre función

    f(a, b, b){}
    
  • Establecer un valor para una variable no declarada

    function f(x){
       "use strict";
       var a = 12;
       b = a + x*35; // error!
    }
    f();
    
  • Usando deleteen un nombre de variabledelete myVariable;

  • Usando evalo argumentscomo variable o nombre de argumento de función

    "use strict";
    arguments++;
    var obj = { set p(arguments) { } };
    try { } catch (arguments) { }
    function arguments() { } 
    

Fuentes:

1
56

El modo estricto realiza varios cambios en la semántica normal de JavaScript:

  • elimina algunos errores silenciosos de JavaScript cambiándolos para que arrojen errores.

  • corrige errores que dificultan que los motores JavaScript realicen optimizaciones.

  • prohíbe alguna sintaxis que probablemente se definirá en versiones futuras de ECMAScript.

para obtener más información, visite el modo estricto - Javascript

55

"Usar estricto"; es un seguro de que el programador no utilizará las propiedades sueltas o malas de JavaScript. Es una guía, al igual que una regla te ayudará a trazar líneas rectas. "Use Strict" le ayudará a realizar una "codificación directa".

Aquellos que prefieren no usar reglas para hacer sus líneas rectas generalmente terminan en esas páginas pidiendo a otros que depuren su código.

Créeme. La sobrecarga es insignificante en comparación con el código mal diseñado. Doug Crockford, que ha sido desarrollador senior de JavaScript durante varios años, tiene una publicación muy interesante aquí . Personalmente, me gusta volver a su sitio todo el tiempo para asegurarme de no olvidar mi buena práctica.

La práctica moderna de JavaScript siempre debe evocar el "uso estricto"; pragma. La única razón por la que el Grupo ECMA ha hecho que el modo "estricto" sea opcional es para permitir que los codificadores menos experimentados accedan a JavaScript y darles tiempo para adaptarse a las nuevas y más seguras prácticas de codificación.

0
49

Incluir use strictal principio de todos sus archivos JavaScript sensibles desde este punto es una pequeña forma de ser un mejor programador de JavaScript y evitar que las variables aleatorias se vuelvan globales y las cosas cambien silenciosamente.

44

Citando de w3schools :

The "use strict" Directive

The "use strict" directive is new in JavaScript 1.8.5 (ECMAScript version 5).

It is not a statement, but a literal expression, ignored by earlier versions of JavaScript.

The purpose of "use strict" is to indicate that the code should be executed in "strict mode".

With strict mode, you can not, for example, use undeclared variables.

Why Strict Mode?

Strict mode makes it easier to write "secure" JavaScript.

Strict mode changes previously accepted "bad syntax" into real errors.

As an example, in normal JavaScript, mistyping a variable name creates a new global variable. In strict mode, this will throw an error, making it impossible to accidentally create a global variable.

In normal JavaScript, a developer will not receive any error feedback assigning values to non-writable properties.

In strict mode, any assignment to a non-writable property, a getter-only property, a non-existing property, a non-existing variable, or a non-existing object, will throw an error.

Consulte http://www.w3schools.com/js/js_strict.asp para obtener más información.

0
38

"use strict"hace que el código JavaScript se ejecute en modo estricto , lo que básicamente significa que todo debe definirse antes de su uso. La razón principal para usar el modo estricto es evitar usos globales accidentales de métodos indefinidos.

También en modo estricto, las cosas se ejecutan más rápido, algunas advertencias o advertencias silenciosas arrojan errores fatales, es mejor usarlo siempre para hacer un código más ordenado.

"use strict"es muy necesario para su uso en ECMA5, en ECMA6 es parte de JavaScript de forma predeterminada , por lo que no es necesario agregarlo si está utilizando ES6.

Mire estas declaraciones y ejemplos de MDN:

The "use strict" Directive
The "use strict" directive is new in JavaScript 1.8.5 (ECMAScript version 5). It is not a statement, but a literal expression, ignored by earlier versions of JavaScript. The purpose of "use strict" is to indicate that the code should be executed in "strict mode". With strict mode, you can not, for example, use undeclared variables.

Examples of using "use strict":
Strict mode for functions: Likewise, to invoke strict mode for a function, put the exact statement "use strict"; (or 'use strict';) in the function's body before any other statements.

1) modo estricto en funciones

 function strict() {
     // Function-level strict mode syntax
     'use strict';
     function nested() { return 'And so am I!'; }
     return "Hi!  I'm a strict mode function!  " + nested();
 }
 function notStrict() { return "I'm not strict."; }

 console.log(strict(), notStrict());

2) modo estricto de todo el script

'use strict';
var v = "Hi! I'm a strict mode script!";
console.log(v);

3) Asignación a un global no modificable

'use strict';

// Assignment to a non-writable global
var undefined = 5; // throws a TypeError
var Infinity = 5; // throws a TypeError

// Assignment to a non-writable property
var obj1 = {};
Object.defineProperty(obj1, 'x', { value: 42, writable: false });
obj1.x = 9; // throws a TypeError

// Assignment to a getter-only property
var obj2 = { get x() { return 17; } };
obj2.x = 5; // throws a TypeError

// Assignment to a new property on a non-extensible object.
var fixed = {};
Object.preventExtensions(fixed);
fixed.newProp = 'ohai'; // throws a TypeError

Puede leer más en MDN .

0
31

Hay una buena charla de algunas personas que estaban en el comité de ECMAScript: Cambios en JavaScript, Parte 1: ECMAScript 5 " sobre cómo el uso incremental del "use strict"conmutador permite a los implementadores de JavaScript limpiar muchas de las características peligrosas de JavaScript sin romper repentinamente todos los sitios web. en el mundo.

Por supuesto, también habla de cuántas de esas fallas son (eran) y cómo ECMAScript 5 las corrige.

26

Pequeños ejemplos para comparar:

Modo no estricto:

for (i of [1,2,3]) console.log(i)
    
// output:
// 1
// 2
// 3

Modo estricto:

'use strict';
for (i of [1,2,3]) console.log(i)

// output:
// Uncaught ReferenceError: i is not defined

Modo no estricto:

String.prototype.test = function () {
  console.log(typeof this === 'string');
};

'a'.test();

// output
// false

String.prototype.test = function () {
  'use strict';
  
  console.log(typeof this === 'string');
};

'a'.test();

// output
// true
0
19

Tenga en cuenta que use strictse introdujo en EcmaScript 5 y se mantuvo desde entonces.

A continuación se muestran las condiciones para activar el modo estricto en ES6 y ES7 :

  • Global code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive (see 14.1.1).
  • Module code is always strict mode code.
  • All parts of a ClassDeclaration or a ClassExpression are strict mode code.
  • Eval code is strict mode code if it begins with a Directive Prologue that contains a Use Strict Directive or if the call to eval is a direct eval (see 12.3.4.1) that is contained in strict mode code.
  • Function code is strict mode code if the associated FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, or ArrowFunction is contained in strict mode code or if the code that produces the value of the function’s [[ECMAScriptCode]] internal slot begins with a Directive Prologue that contains a Use Strict Directive.
  • Function code that is supplied as the arguments to the built-in Function and Generator constructors is strict mode code if the last argument is a String that when processed is a FunctionBody that begins with a Directive Prologue that contains a Use Strict Directive.
14

Las principales razones por las que los desarrolladores deberían utilizar "use strict"son:

  1. Evita la declaración accidental de variables globales . El uso "use strict()"asegurará que las variables se declaren varantes de su uso. P.ej:

    function useStrictDemo(){
     'use strict';
     //works fine
     var a = 'No Problem';
    
     //does not work fine and throws error
     k = "problem"
    
     //even this will throw error
     someObject = {'problem': 'lot of problem'};
    }
    
  2. NB: La "use strict"directiva solo se reconoce al comienzo de un script o una función.
  3. La cadena "arguments"no se puede utilizar como variable:

    "use strict";
    var arguments = 3.14;    // This will cause an error
    
  4. Restringirá el uso de palabras clave como variables. Intentar usarlos arrojará errores.

En resumen, hará que su código sea menos propenso a errores y, a su vez, hará que escriba un buen código.

Para leer más al respecto, puede consultar aquí .

0
13

El modo "estricto" de JavaScript se introdujo en ECMAScript 5.

(function() {
  "use strict";
  your code...
})();

Escribir "use strict";en la parte superior de su archivo JS activa una comprobación de sintaxis estricta. Realiza las siguientes tareas por nosotros:

  1. muestra un error si intenta asignar a una variable no declarada

  2. evita que sobrescriba las bibliotecas clave del sistema JS

  3. prohíbe algunas funciones de lenguaje inseguras o propensas a errores

use stricttambién funciona dentro de funciones individuales. Siempre es una mejor práctica incluirlo use stricten su código.

Problema de compatibilidad del navegador: las directivas "use" están destinadas a ser compatibles con versiones anteriores. Los navegadores que no los admitan solo verán un literal de cadena al que no se hace referencia adicional. Entonces, lo pasarán por alto y seguirán adelante.

13

use strictes una forma de hacer que su código sea más seguro, porque no puede usar características peligrosas que pueden funcionar no como espera. Y, como se escribió antes, hace que el código sea más estricto.

12

"uso estricto"; es el esfuerzo de ECMA para hacer que JavaScript sea un poco más robusto. Trae a JS un intento de hacerlo al menos un poco "estricto" (otros lenguajes implementan reglas estrictas desde los años 90). En realidad, "obliga" a los desarrolladores de JavaScript a seguir algún tipo de mejores prácticas de codificación. Aún así, JavaScript es muy frágil. No existen variables escritas, métodos escritos, etc. Recomiendo encarecidamente a los desarrolladores de JavaScript que aprendan un lenguaje más sólido, como Java o ActionScript3, e implementen las mismas prácticas recomendadas en su código JavaScript, funcionará mejor y será más fácil depurar.

12

Normalmente, JavaScript no sigue reglas estrictas, por lo que aumentan las posibilidades de errores. Después de su uso "use strict", el código JavaScript debe seguir un conjunto estricto de reglas como en otros lenguajes de programación, como el uso de terminadores, declaración antes de la inicialización, etc.

Si "use strict"se usa, el código debe escribirse siguiendo un conjunto estricto de reglas, lo que reduce las posibilidades de errores y ambigüedades.

0
11

Use Strict se usa para mostrar errores comunes y repetidos para que se maneje de manera diferente y cambie la forma en que se ejecuta el script java, tales cambios son:

  • Previene globales accidentales

  • Sin duplicados

  • Elimina con

  • Elimina esta coacción

  • Eval () más seguro

  • Errores for inmutables

También puede leer este artículo para obtener más detalles.

7

"uso estricto"; Define que el código JavaScript debe ejecutarse en "modo estricto".

  • La directiva de "uso estricto" era nueva en ECMAScript versión 5.
  • No es una declaración, sino una expresión literal, ignorada por versiones anteriores de JavaScript.
  • El propósito de "usar estricto" es indicar que el código debe ejecutarse en "modo estricto".
  • Con el modo estricto, no puede, por ejemplo, utilizar variables no declaradas.

Todos los navegadores modernos admiten el "uso estricto", excepto Internet Explorer 9 y versiones anteriores .

Desventaja

Si un desarrollador usó una biblioteca que estaba en modo estricto, pero el desarrollador estaba acostumbrado a trabajar en modo normal, podría llamar a algunas acciones en la biblioteca que no funcionarían como se esperaba.

Peor aún, dado que el desarrollador está en modo normal, no tiene las ventajas de que se produzcan errores adicionales, por lo que el error puede fallar silenciosamente.

Además, como se mencionó anteriormente, el modo estricto le impide hacer ciertas cosas.

La gente generalmente piensa que no debería usar esas cosas en primer lugar, pero a algunos desarrolladores no les gusta la restricción y quieren usar todas las características del lenguaje.

4

El modo estricto puede evitar pérdidas de memoria.

Verifique la función a continuación escrita en modo no estricto:

function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); // Stack Overflow

En esta función, estamos usando una variable llamada namedentro de la función. Internamente, el compilador primero verificará si hay alguna variable declarada con ese nombre en particular en el alcance de esa función en particular. Dado que el compilador entendió que no existe tal variable, verificará el alcance externo. En nuestro caso, es el ámbito global. Una vez más, el compilador entendió que tampoco hay ninguna variable declarada en el espacio global con ese nombre, por lo que nos crea esa variable en el espacio global. Conceptualmente, esta variable se creará en el ámbito global y estará disponible en toda la aplicación.

Otro escenario es que, digamos, la variable se declara en una función secundaria. En ese caso, el compilador verifica la validez de esa variable en el ámbito externo, es decir, la función padre. Solo entonces comprobará el espacio global y creará una variable para nosotros allí. Eso significa que es necesario realizar comprobaciones adicionales. Esto afectará el rendimiento de la aplicación.


Ahora escribamos la misma función en modo estricto.

"use strict"
function getname(){
    name = "Stack Overflow"; // Not using var keyword
    return name;
}
getname();
console.log(name); 

Obtendremos el siguiente error.

Uncaught ReferenceError: name is not defined
at getname (<anonymous>:3:15)
at <anonymous>:6:5

Aquí, el compilador arroja el error de referencia. En modo estricto, el compilador no nos permite usar la variable sin declararla. Así se pueden prevenir las pérdidas de memoria. Además, podemos escribir código más optimizado.

3

El modo estricto elimina los errores que se ignorarían en el modo no estricto, lo que hace que JavaScript sea "más seguro".

Is it considered among best practices?

, se considera parte de las mejores prácticas al trabajar con javascript para incluir el modo estricto . Esto se hace agregando la siguiente línea de código en su archivo JS.

'use strict';

en su código.

What does it mean to user agents?

Al indicar que el código debe interpretarse en modo estricto, se especifica a los agentes de usuario, como los navegadores, que deben tratar el código literalmente como está escrito y generar un error si el código no tiene sentido.

Por ejemplo: considere que en su .jsarchivo tiene el siguiente código:

Escenario 1: [SIN MODO ESTRICTO]

var city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

Escenario 2: [SIN MODO ESTRICTO]

city = "Chicago"
console.log(city) // Prints the city name, i.e. Chicago

So why does the variable name is being printed in both cases?

Sin el modo estricto activado, los agentes de usuario a menudo pasan por una serie de modificaciones en el código problemático en un intento de hacer que tenga sentido. En la superficie, esto puede parecer algo bueno y, de hecho, trabajar fuera del modo estricto hace posible que las personas se mojen los pies con el código JavaScript sin tener todos los detalles bien definidos. Sin embargo, como desarrollador, no quiero dejar un error en mi código, porque sé que podría volver y morderme más adelante, y también solo quiero escribir un buen código. Y ahí es donde el modo estricto ayuda.

Escenario 3: [MODO ESTRICTO]

'use strict';

city = "Chicago"
console.log(city) // Reference Error: asignment is undeclared variable city.

Consejo adicional: para mantener la calidad del código usando el modo estricto, no necesita escribir esto una y otra vez, especialmente si tiene varios.jsarchivos. Puede hacer cumplir esta regla globalmente eneslintreglas de la siguiente manera:

Nombre del archivo: .eslintrc.js

module.exports = {
    env: {
        es6: true
    },
    rules : {
        strict: ['error', 'global'],
        },
    };
    

Okay, so what is prevented in strict mode?

  • Usar una variable sin declararla arrojará un error en modo estricto. Esto es para evitar la creación involuntaria de variables globales en toda su aplicación. El ejemplo de la imprenta Chicago cubre esto en particular.

  • Eliminar una variable, una función o un argumento es un no-no en modo estricto.

    "use strict";
     function x(p1, p2) {}; 
     delete x; // This will cause an error
    
  • Duplicación de un nombre de parámetro es no permitido en el modo estricto.

     "use strict";
     function x(p1, p1) {};   // This will cause an error
    
  • Las palabras reservadas en el lenguaje Javascript no están permitidas en modo estricto. Las palabras son interfaz de implementos, dejar, paquetes, privado, protegido, público. estático y rendimiento

Para obtener una lista más completa, consulte la documentación de MDN aquí: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode

0

JavaScript fue diseñado e implementado apresuradamente debido a guerras de navegadores y mala administración. Como resultado, muchas decisiones de diseño deficientes, una sintaxis poco intuitiva y una semántica confusa se abrieron paso en el lenguaje. El modo estricto tiene como objetivo corregir algunos de estos errores.

Pero corregir estos errores sin crear una interpretación alternativa rompe la compatibilidad con versiones anteriores. Entonces, la "use strict"directiva crea esa interpretación alternativa del código mientras se lo comunica al programador.

Por ejemplo, las thispalabras clave se refieren al objeto en una definición de método, como thiso selfen otros lenguajes.

let o = {
  name: 'John Doe',
  sayName: function(){
    console.log(this.name);
  }
};

o.sayName(); // 'John Doe'

thisno tiene ningún propósito fuera del contexto del método, pero todas las funciones de JavaScript tienen thispalabras clave, ya sean métodos o no:

function run() {
  console.log(this);
}

run(); // Window

Aquí se thisresuelve en el objeto global que no tiene sentido y no tiene ningún propósito porque el objeto global ya está disponible en el alcance.

En modo estricto, thisuna función global se resuelve en indefinido, que es lo que esperamos.

"use strict"

function run() {
  console.log(this);
}

run(); // undefined

Algunos errores no se pueden corregir incluso en modo estricto porque la sintaxis debería ser válida para navegadores más antiguos, ya que ignoran la "strict mode"directiva. Esto es por diseño.