O que "use strict" faz em JavaScript e quais são as razões para isso?

Eu lancei recentemente meu código JavaScript através do Crockford JSLint , e ele deu o seguinte erro:

Problema na linha 1 caractere 1: ausente "usar estrito" declaração.

Ao fazer algumas pesquisas, percebi que algumas pessoas adicionam "use strict"; no seu código javascript. Assim que adicionei a expressão, o erro deixou de aparecer. Infelizmente, o Google não revelou a maior parte da história dessa linha de operador. É claro que isso deve estar relacionado à maneira como o JavaScript é interpretado pelo navegador, mas não sei qual será o efeito.

Então, o que é "use strict"; é tudo sobre o que isso implica, e ainda é relevante?

Qualquer navegador atual responde a "use strict"; string ou é para uso futuro?

6989
26 авг. definido por Mark Rogers 26 ago. 2009-08-26 19:10 '09 às 19:10 2009-08-26 19:10
@ 30 respostas

Este artigo sobre o Javascript Strict Mode pode lhe interessar: John Resig - ECMAScript 5 Strict Mode, JSON e muito mais

Para citar algumas partes interessantes:

O modo estrito é um novo recurso do ECMAScript 5 que permite colocar um programa ou função em um contexto de trabalho "estrito". Esse contexto estrito impede que determinadas ações sejam tomadas e gera mais exceções.

Também:

O modo estrito ajuda de várias maneiras:

  • Ele pega alguns erros comuns de codificação, lançando exceções.
  • Isso evita ou cria erros quando ações relativamente "não seguras" são tomadas (por exemplo, obter acesso a um objeto global).
  • Isso desativa recursos que são confusos ou mal pensados.

Observe também que você pode aplicar o "modo estrito" ao arquivo inteiro ... Ou você pode usá-lo apenas para uma função específica (ainda citando o artigo de John Resig):

 // Non-strict code... (function(){ "use strict"; // Define your library strictly... })(); // Non-strict code... 

O que pode ser útil se você precisar misturar código antigo e novo ;-)

Então eu suponho que é um pouco como "use strict" você pode usar em Perl (daí o nome?): Ele ajuda você a cometer menos erros, encontrando mais coisas que podem levar a avarias.

Atualmente, é suportado por todos os principais navegadores (painel IE 9 e abaixo).

4587
26 авг. a resposta é dada por Pascal MARTIN 26 ago. 2009-08-26 19:15 '09 às 19:15 2009-08-26 19:15

Este é um novo recurso do ECMAScript 5. John Resig escreveu um bom resumo .

Esta é apenas uma linha que você coloca em seus arquivos JavaScript (no topo do seu arquivo, ou dentro de uma função), que se parece com isso:

border=0
 "use strict"; 

A ativação deste código não deve mais causar problemas nos navegadores atuais, já que isso é apenas uma string. Isso pode causar problemas com seu código no futuro se seu código quebrar um pragma. Por exemplo, se você atualmente tem foo = "bar" sem primeiro definir foo , seu código irá falhar ... o que, na minha opinião, é bom.

1152
26 авг. a resposta é dada seth 26 ago. 2009-08-26 19:14 '09 at 7:14 PM 2009-08-26 19:14

A declaração "use strict"; instrui o navegador a usar o modo Strict, que é um conjunto reduzido e mais seguro de funções JavaScript.

Lista de funções (não exaustivas)

  1. Não permite variáveis ​​globais. (Remove declarações var e erros de digitação em nomes de variáveis)

  2. Tarefas com falhas silenciosas causarão um erro no modo estrito (atribuindo NaN = 5; )

  3. Tentativas de remover propriedades tolerantes a falhas causarão ( delete Object.prototype )

  4. Requer que todos os nomes de propriedade no literal do objeto sejam exclusivos ( var x = {x1: "1", x1: "2"} )

  5. Os nomes dos parâmetros de função devem ser exclusivos ( function sum (x, x) {...} )

  6. Proibida a sintaxe octal ( var x = 023; alguns desenvolvedores acreditam erroneamente que o zero anterior não faz nada para alterar o número).

  7. Proibindo with palavra with chave

  8. eval no modo estrito não introduz novas variáveis

  9. Desativar a exclusão de nome simples ( delete x; )

  10. Desativando a ligação ou nomeação de eval e arguments em qualquer forma

  11. O modo estrito não suporta as propriedades do objeto de arguments com parâmetros formais. (isto é, na function sum (a,b) { return arguments[0] + b;} Isso funciona porque os arguments[0] estão associados a a , etc.)

  12. arguments.callee não arguments.callee suportado

[Link: Modo Estrito , Mozilla Developer Network]

567
25 нояб. a resposta é dada por gprasant 25 nov. 2014-11-25 00:22 '14 às 00:22 2014-11-25 00:22

Se as pessoas estão preocupadas com o use strict , é possível conferir este artigo:

Suporte ao ECMAScript 5 Strict Mode nos navegadores. O que isso significa?
NovoGeek.com - Blog de Krishna

Ele fala sobre o suporte ao navegador, mas mais importante, como lidar com isso:

 function isStrictMode(){ return !this; }  function isStrictMode(){ "use strict"; return !this; }  
385
16 июля '12 в 2:25 2012-07-16 02:25 Resposta é dada por Jamie Hutber 16 de julho, '12 at 2:25 am 2012-07-16 02:25

Uma palavra de cautela, qualquer coisa que você programar com cobrança difícil: aplicar "use strict" ao código existente pode ser perigoso! Essa coisa não é algum tipo de adesivo legal e agradável que você possa usar no código para torná-lo "melhor". Com o "use strict" correto "use strict" pragmas, o navegador de repente lança exceções em lugares aleatórios que nunca jogou antes, simplesmente porque neste lugar você faz o que JavaScript permite padrão / livre, mas não como JavaScript estrito ! Você pode ter violações estritas ocultas em chamadas raramente usadas para o seu código, que gerarão uma exceção somente quando estiverem em execução no final - digamos, em um ambiente de produção que seus clientes de pagamento usam!

Se você for dar um passo decisivo, recomendamos usar "use strict" junto com testes unitários abrangentes e a tarefa de construção JSHint estritamente configurada, que lhe dará a certeza de que não haverá canto escuro do seu módulo que explodirá mal porque você ativou o modo estrito. Ou, ei, aqui está outra opção: só não adicione o "use strict" a qualquer um dos seus códigos desatualizados, isso provavelmente é mais seguro, honesto. DEFINITIVAMENTE NÃO adicione "use strict" para quaisquer módulos que você não possua ou suporte, como módulos de terceiros.

Eu acho que mesmo que seja um estômago mortal em uma gaiola, "use strict" pode ser bom, mas você tem que fazer certo. A melhor época para ir rigoroso é quando seu projeto é novo e você começa do zero. Configure o JSHint/JSLint com todos os avisos e opções dobrados da maneira que sua equipe pode sofrer, obtenha um bom sistema de compilação / teste / aprovação que possa ser configurado como Grunt+Karma+Chai , e somente THEN marcará todos os seus novos módulos como "use strict" . Esteja preparado para curar muitos erros e avisos. Certifique-se de que todos entendam a gravidade definindo a montagem como FAIL se o JSHint/JSLint causar alguma irregularidade.

Meu projeto não era um projeto novo quando eu adotei "use strict" . Como resultado, meu IDE está cheio de marcas vermelhas, porque eu não "use strict" em metade dos meus módulos, e o JSHint reclama disso. Este é um lembrete para mim do que eu deveria fazer no futuro. Meu objetivo é ser uma marca vermelha de graça por causa de todas as minhas declarações "use strict" , mas isso tem sido por muitos anos.

193
03 марта '14 в 10:37 2014-03-03 10:37 Resposta é dada por DWoldrich em 03 de março '14 às 10:37 2014-03-03 10:37

Use 'use strict'; não melhora o seu código.

Estrito modo JavaScript é uma função no ECMAScript 5 . Você pode ativar o modo estrito declarando isso no topo de seu script / função.

 'use strict'; 

Quando o mecanismo de JavaScript vê essa diretiva, ela começará a interpretar o código em um modo especial. Nesse modo, erros ocorrem quando determinados métodos de codificação são detectados, o que pode ser um possível erro (que é um argumento a favor do modo estrito).

Considere este exemplo:

 var a = 365; var b = 030; 

Em sua obsessão de construir literais numéricos, o desenvolvedor inadvertidamente inicializou a variável b oitavo literal. Um modo não estrito interpretará isso como um literal numérico com um valor de 24 (na base 10). No entanto, o modo estrito causará um erro.

Para obter uma lista não exaustiva de especialidades no modo estrito, consulte Esta resposta .


Onde devo usar 'use strict'; ?

  • No meu novo aplicativo de javascript: Absolutamente! O modo estrito pode ser usado como um informante quando você faz algo estúpido com seu código.

  • No meu código javascript existente: Provavelmente não! Se o seu código JavaScript existente contiver instruções proibidas no modo estrito, o aplicativo simplesmente será interrompido. Se você precisar de modo estrito, você deve estar pronto para depurar e corrigir o código existente. É por isso que o uso de 'use strict'; não melhora o seu código.


Como usar o modo estrito?

  1. Inserir 'use strict'; no topo do seu script:

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

    Por favor, note que tudo em myscript.js será interpretado no modo estrito.

  2. Ou cole 'use strict'; A declaração acima das funções do seu corpo:

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

    Tudo no escopo léxico da função doSomething será interpretado no modo estrito. A área lexical da palavra é importante aqui. Veja esta resposta para uma melhor explicação.


Quais são as coisas estritamente proibidas?

Eu encontrei um bom artigo descrevendo várias coisas que são estritamente proibidas (note que esta não é uma lista exclusiva):

Volume

Historicamente, o JavaScript ficou confuso sobre como as funções são cobertas. Às vezes, eles parecem ser capturados estaticamente, mas algumas funções os forçam a se comportar como se estivessem dinamicamente cobertos por uma região. Isso é confuso, o que dificulta a leitura e a compreensão dos programas. Mal-entendido causa erros. Este também é um problema de desempenho. Uma definição de domínio estático permitiria a vinculação de variáveis ​​em tempo de compilação, mas o requisito para um domínio dinâmico significa que a vinculação deve ser adiada até o tempo de execução, que está associada a uma redução significativa no desempenho.

O modo estrito requer que todas as ligações de variáveis ​​sejam executadas estaticamente. Isso significa que as funções que antes exigiam a vinculação dinâmica devem ser eliminadas ou modificadas. Em particular, o operador com é excluído, e a capacidade das funções eval de interferir com o ambiente do chamador é estritamente limitada.

Uma das vantagens do código estrito é que ferramentas como o YUI Compressor podem funcionar melhor no processamento.

Variáveis ​​globais implícitas

JavaScript implica variáveis ​​globais. Se você não declarar explicitamente uma variável, uma variável global será implicitamente declarada para você. Isso simplifica a programação para iniciantes, porque eles podem negligenciar algumas de suas principais tarefas de negócios. Mas isso dificulta o gerenciamento de programas maiores e reduz significativamente a confiabilidade. Assim, no modo estrito, as variáveis ​​globais implícitas não são mais criadas. Você deve declarar explicitamente todas as suas variáveis.

Vazamentos globais

Há várias situações que podem fazer com que this seja associado a um objeto global. Por exemplo, se você esqueceu de fornecer new prefixo quando chamar uma função construtora, o construtor this será associado inesperadamente a um objeto global, portanto, em vez de inicializar um novo objeto, ele falsificará silenciosamente com variáveis ​​globais. Nessas situações, o modo estrito vincula this a undefined , o que faz com que o construtor lance uma exceção, permitindo que ele detecte o erro anteriormente.

Erro barulhento

O JavaScript sempre teve propriedades somente leitura, mas você não pode criá-las sozinho até que a função Object.createProperty seja Object.createProperty aberta para a função Object.createProperty . Se você tentou atribuir um valor a uma propriedade somente leitura, ele falhará. A atribuição não alterará o valor da propriedade, mas seu programa agirá como se fosse. Este é um perigo de integridade, que pode levar à transição de programas em um estado inconsistente. No modo estrito, tentar alterar a propriedade somente leitura causará uma exceção.

octal

A representação de números de 8 bits foi extremamente útil ao executar a programação de máquinas em máquinas cujo tamanho de palavra era múltiplo de 3. Ao trabalhar com o mainframe CDC 6600, com um tamanho de palavra de 60 bits, era necessário um número octal. Se você pudesse ler octal, poderia ver a palavra como 20 dígitos. Dois dígitos representaram o código op e um dígito identificou um dos 8 registros. Durante a lenta transição de códigos de máquinas para linguagens de alto nível, considerou-se útil fornecer formulários octal em linguagens de programação.

Em C, a idéia extremamente infeliz de octalidade foi escolhida: o zero inicial. Então, em C 0100 significa 64, não 100, e 08 é um erro, não 8. Ainda mais, infelizmente, esse anacronismo foi copiado para quase todas as linguagens modernas, incluindo JavaScript, onde é usado apenas para criar erros. Isso não tem outro propósito. Assim, no modo estrito, os formulários octal não são mais permitidos.

Etcetera

Os argumentos do pseudo array se tornam um pouco mais parecidos com os arrays no ES5. No modo estrito, ele perde as propriedades de caller e caller . Isso permite que você passe seus arguments código não confiável, sem deixar muito contexto confidencial. Além disso, a propriedade arguments de funções é excluída.

No modo estrito, as chaves duplicadas em um literal de função geram um erro de sintaxe. O não pode funcionar tem dois parâmetros com o mesmo nome. A função não pode ter uma variável com o mesmo nome de um dos seus parâmetros. A função não pode delete possui suas próprias variáveis. A tentativa de delete propriedade não configurável agora lança uma exceção. Valores primitivos não estão implicitamente envolvidos.


Palavras reservadas para futuras versões do javascript

O ECMAScript 5 adiciona uma lista de palavras reservadas. Se você usá-los como variáveis ​​ou argumentos, o modo estrito gerará um erro. Palavras reservadas:

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


Leitura adicional

144
29 янв. Resposta dada por sampathsris 29 de jan 2016-01-29 14:35 '16 às 14:35 2016-01-29 14:35

Eu recomendo fortemente que todos os desenvolvedores comecem a usar o modo estrito. Existem navegadores suficientes que o suportam e que o modo estrito legalmente nos ajudará a evitar erros que nem sabíamos que estavam em seu código.

Aparentemente, no estágio inicial, haverá erros que nunca encontramos antes. Para obter o benefício total, precisamos realizar testes adequados depois de alternar para o modo estrito para garantir que todos nós seremos pegos. Definitivamente, nós simplesmente não use strict em nosso código e acreditamos que não há erros. Então, a rotatividade é que é hora de começar a usar esse recurso de linguagem incrivelmente útil para escrever um código melhor.

Por exemplo

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

JSLint é um depurador escrito por Douglas Crockford. Basta colá-lo em seu script e ele procurará rapidamente por quaisquer problemas e erros visíveis em seu código.

128
05 июля '13 в 22:38 2013-07-05 22:38 a resposta é dada a Pank em 05 de julho '13 às 10:38 2013-07-05 22:38

Eu gostaria de oferecer uma resposta um pouco mais fundamentada que complementa as outras respostas. Eu esperava editar a resposta mais popular, mas não consegui. Tentei torná-lo o mais completo e completo possível.

Para mais informações, você pode consultar a documentação do MDN .

"use strict" diretiva "use strict" inserida no ECMAScript 5.

Diretivas são como declarações, mas diferentes.

  • use strict não contém palavras-chave: uma diretiva é uma declaração de expressão simples que consiste em um literal de string especial (em aspas simples ou duplas). Mecanismos JavaScript que não implementam ECMAScript 5 simplesmente vêem a expressão sem efeitos colaterais. Espera-se que versões futuras dos padrões ECMAScript introduzam o use como uma palavra-chave real; Assim, as cotações se tornarão obsoletas.
  • use strict só pode ser usado no início de um script ou função, ou seja, deve preceder qualquer outra declaração (real). Esta não deve ser a primeira instrução em um script de função: ela pode ser precedida por outras expressões de operador que consistem em literais de string (e implementações de JavaScript podem ser visualizadas como diretivas específicas da implementação). Literais de sequência que seguem o primeiro operador real (em um script ou função) são expressões simples. Os intérpretes não devem interpretá-los como diretivas, e eles não têm efeito.

use strict diretiva use strict indica que o código a seguir (em um script ou função) é um código estrito. O código no nível mais alto do script (código que não está na função) é considerado um código estrito quando o script contém o use strict use strict . O conteúdo de uma função é considerado código estrito quando a própria função é definida em código estrito ou quando a função contém a diretiva use strict . O código passado para o método eval() é considerado um código estrito quando eval() é chamado de um código de string ou contém a diretiva use strict .

O ECMAScript 5 strict mode é um subconjunto limitado da linguagem JavaScript, que elimina as falhas de linguagem correspondentes e fornece uma verificação de erros mais rigorosa e maior segurança. A seguir estão as diferenças entre o modo estrito e o modo normal (dos quais os três primeiros são particularmente importantes):

  • Você não pode usá-lo with -statement no modo estrito.
  • No modo estrito, todas as variáveis ​​devem ser declaradas: se você atribuir um valor a um identificador que não tenha sido declarado como uma variável, uma função, um parâmetro de função, um parâmetro catch-clause ou uma propriedade global Object , você obterá um ReferenceError . В нормальном режиме идентификатор объявляется неявно как глобальная переменная (как свойство глобального Object )
  • В строгом режиме ключевое слово this имеет значение undefined функции, которые были вызываться как функции ( а не как методы). (В нормальном режиме this всегда указывает на глобальный Object ). Это различие можно использовать для проверки, поддерживает ли реализация строгий режим:
 var hasStrictMode = (function() { "use strict"; return this===undefined }()); 
  • Также, когда функция вызывается с call() или apply в строгом режиме, this точно значение первого аргумента call() или apply() . (В нормальном режиме null и undefined заменяются глобальным Object а значения, которые не являются объектами, преобразуются в объекты.)

  • В строгом режиме вы получите TypeError , когда вы пытаетесь назначить свойства readonly или определить новые свойства для не растяжимого объекта. (В обычном режиме оба просто обходятся без сообщения об ошибке.)

  • В строгом режиме при передаче кода в eval() вы не можете объявлять или определять переменные или функции в области вызывающего (как это можно сделать в обычном режиме). Вместо этого для eval() создается новая область, и переменные и функции находятся в пределах этой области. Эта область уничтожается после того, как eval() завершает выполнение.
  • В строгом режиме аргумент-объект функции содержит статическую копию значений, которые передаются этой функции. В нормальном режиме аргумент-объект имеет несколько "магическое" поведение: элементы массива и именованные функциональные параметры ссылаются на одно и то же значение.
  • В строгом режиме вы получите SyntaxError когда за оператором delete следует неквалифицированный идентификатор (переменная, функция или параметр функции). В нормальном режиме выражение delete ничего не сделает и будет оценено как false .
  • В строгом режиме вы получите TypeError при попытке удалить неконфигурируемое свойство. (В обычном режиме попытка просто терпит неудачу, а выражение delete - false ).
  • В строгом режиме это считается синтаксической ошибкой при попытке определить несколько свойств с тем же именем для литерала объекта. (В нормальном режиме ошибки нет.)
  • В строгом режиме это считается синтаксической ошибкой, когда объявление функции имеет несколько параметров с тем же именем. (В нормальном режиме ошибки нет.)
  • В строгом режиме не допускаются восьмеричные литералы (это литералы, начинающиеся с 0x . (В нормальном режиме некоторые реализации позволяют делать восьмеричные литералы).
  • В строгом режиме идентификаторы eval и arguments обрабатываются как ключевые слова. Вы не можете изменить их значение, не можете присвоить им значение, и вы не можете использовать их в качестве имен для переменных, функций, параметров функций или идентификаторов блока catch.
  • В строгом режиме больше ограничений на возможности проверки стека вызовов. arguments.caller и arguments.callee вызывают TypeError в функции в строгом режиме. Кроме того, некоторые свойства caller- и аргументы функций в строгом режиме вызывают TypeError при попытке их прочитать.
88
ответ дан Ely 15 мая '15 в 9:58 2015-05-15 09:58