O que “use strict” faz em JavaScript e qual é o raciocínio por trás disso?

StackOverflow https://stackoverflow.com/questions/1335851

Pergunta

Recentemente, executei alguns dos meus códigos JavaScript através do Crockford's JSLint, e deu o seguinte erro:

Problema na linha 1, caractere 1:Falta a instrução "use strict".

Fazendo algumas pesquisas, percebi que algumas pessoas adicionam "use strict"; em seu código JavaScript.Depois de adicionar a instrução, o erro parou de aparecer.Infelizmente, o Google não revelou muito da história por trás dessa declaração de string.Certamente deve ter algo a ver com a forma como o JavaScript é interpretado pelo navegador, mas não tenho ideia de qual seria o efeito.

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

Algum dos navegadores atuais responde ao "use strict"; string ou é para uso futuro?

Foi útil?

Solução

Este artigo sobre o modo rigoroso JavaScript pode lhe interessar: John Resig - Ecmascript 5 Strict Mode, JSON e muito mais

Para citar algumas partes interessantes:

O modo rigoroso é um novo recurso no ECMAScript 5 que permite colocar um programa ou uma função, em um contexto operacional "rigoroso". Esse contexto estrito impede que certas ações sejam tomadas e lança mais exceções.

E:

O modo rigoroso ajuda de algumas maneiras:

  • Ele pega alguns erros de codificação comuns, jogando exceções.
  • Impede ou lança erros, quando ações relativamente "inseguras" são tomadas (como obter acesso ao objeto global).
  • Ele desativa os recursos confusos ou mal pensados.

Observe também que você pode aplicar "modo rigoroso" a todo o arquivo ... ou você pode usá -lo apenas para uma função específica (ainda citando do 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, acho que é um pouco como o "use strict" você pode usar em perl (daí o nome?): Ajuda você a cometer menos erros, detectando mais coisas que podem levar a quebras.

O modo rigoroso é agora Apoiado por todos os principais navegadores.

Lado de dentro Módulos nativos do ecmascript (com import e export declarações) e Classes ES6, o modo rigoroso está sempre ativado e não pode ser desativado.

Outras dicas

É um novo recurso do Ecmascript 5. John Resig escreveu Um bom resumo disso.

É apenas uma string que você coloca em seus arquivos JavaScript (na parte superior do seu arquivo ou dentro de uma função) que se parece com o seguinte:

"use strict";

Colocá -lo no seu código agora não deve causar problemas com os navegadores atuais, pois é apenas uma string. Pode causar problemas com seu código no futuro se o seu código violar o Pragma. Por exemplo, se você tem atualmente foo = "bar" sem definir foo Primeiro, seu código começará a falhar ... o que é uma coisa boa na minha opinião.

A declaração "use strict"; instrui o navegador a usar o modo Estrito, que é um conjunto de recursos reduzido e mais seguro do JavaScript.

Lista de recursos (não exaustiva)

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

  2. Atribuições com falha silenciosa gerarão erros no modo estrito (atribuir NaN = 5;)

  3. As tentativas de excluir propriedades que não podem ser excluídas gerarão (delete Object.prototype)

  4. Requer que todos os nomes de propriedades em um literal de 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. Proíbe a sintaxe octal (var x = 023; alguns desenvolvedores assumem erroneamente que um zero anterior não altera o número.)

  7. Proíbe o with palavra-chave

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

  9. Proíbe a exclusão de nomes simples (delete x;)

  10. Proíbe vinculação ou atribuição dos nomes eval e arguments em qualquer forma

  11. O modo estrito não cria alias de propriedades do arguments objeto com os parâmetros formais.(ou seja,em function sum (a,b) { return arguments[0] + b;} Isso funciona porque arguments[0] é obrigado a a e assim por diante.)

  12. arguments.callee não é suportado

[Ref: Modo estrito, Rede de desenvolvedores Mozilla]

Se as pessoas estão preocupadas em usar use strict Pode valer a pena conferir este artigo:

ECMAScript 5 'Modo Estrito' Suporte em navegadores. O que isto significa?
NovoGeek.com - weblog de Krishna

Ele fala sobre o suporte do navegador, mas mais importante como lidar com isso com segurança:

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.
*/

Uma palavra de cautela, todos vocês programadores de carga dura: aplicação "use strict" ao código existente pode ser perigoso! Essa coisa não é um adesivo de boa aparência e boa cara que você pode dar um tapa no código para torná-lo 'melhor'. Com o "use strict" Pragma, o navegador repentinamente jogará exceções em lugares aleatórios que nunca jogou antes, apenas porque naquele local você está fazendo algo que JavaScript padrão/solto permite felizmente, mas rigoroso JavaScript abomina! Você pode ter violações de restrição escondidas em chamadas raramente usadas em seu código que apenas lançarão uma exceção quando elas forem executadas - digamos, no ambiente de produção que seus clientes pagantes usam!

Se você vai mergulhar, é uma boa ideia aplicar "use strict" Juntamente com testes de unidade abrangentes e uma tarefa estritamente configurada de construção de jshint que lhe dará alguma confiança de que não há canto escuro do seu módulo que explodirá terrivelmente apenas porque você ligou o modo rigoroso. Ou, ei, aqui está outra opção: apenas não adicione "use strict" Para qualquer seu código legado, provavelmente é mais seguro dessa maneira, honestamente. Definitivamente não adicionar "use strict" Para quaisquer módulos que você não possua ou mantém, como módulos de terceiros.

Eu acho que mesmo que seja um animal enjaulado mortal, "use strict" pode ser uma coisa boa, mas você precisa fazer o que é certo. A melhor época para ir rigorosa é quando seu projeto é Greenfield e você está começando do zero. Configure JSHint/JSLint Com todos os avisos e opções aumentados o mais apertado possível Grunt+Karma+Chai, e só então comece a marcar todos os seus novos módulos como "use strict". Esteja preparado para curar muitos erros e advertências noturnos. Certifique -se de que todos entendam a gravidade, configurando a construção para falhar se JSHint/JSLint produz violações.

Meu projeto não era um projeto Greenfield quando adotei "use strict". Como resultado, meu IDE está cheio de marcas vermelhas porque eu não tenho "use strict" em metade dos meus módulos, e Jshint reclama disso. É um lembrete para mim sobre o que a refatoração eu deveria fazer no futuro. Meu objetivo é estar livre de marcas vermelhas devido a toda a minha falta "use strict" declarações, mas isso está a anos agora.

Usando 'use strict'; não torna seu código melhor de repente.

O Modo estrito de JavaScript é uma característica em ECMAScript 5.Você pode ativar o modo estrito declarando isso no topo do seu script/função.

'use strict';

Quando um mecanismo JavaScript vê isso diretiva, ele começará a interpretar o código em um modo especial.Neste modo, erros são gerados quando certas práticas de codificação que podem acabar sendo possíveis bugs são detectadas (que é o raciocínio por trás do modo estrito).

Considere este exemplo:

var a = 365;
var b = 030;

Em sua obsessão em alinhar os literais numéricos, o desenvolvedor inicializou inadvertidamente a variável b com um literal octal.O modo não estrito interpretará isso como um literal numérico com valor 24 (na base 10).No entanto, o modo estrito gerará um erro.

Para uma lista não exaustiva de especialidades em modo estrito, ver esta resposta.

Onde devo usar 'use strict';?

  • No meu novo Aplicativo JavaScript: Absolutamente! O modo estrito pode ser usado como denunciante quando você está fazendo algo estúpido com seu código.

  • No meu existir Código JavaScript: Provavelmente não! Se o seu código JavaScript existente tiver instruções proibidas no modo estrito, o aplicativo simplesmente quebrará.Se desejar o modo estrito, você deve estar preparado para depurar e corrigir seu código existente.Isso é por que usando 'use strict'; não torna seu código melhor de repente.

Como faço para usar o modo estrito?

  1. Insira um 'use strict'; declaração no topo do seu script:

    // File: myscript.js

'use strict';
var a = 2;
....

    Observe que tudo no arquivo myscript.js será interpretado em modo estrito.

  2. Ou insira um 'use strict'; instrução no topo do corpo da sua função:

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

    Tudo no escopo lexical de função doSomething será interpretado em modo estrito.A palavra escopo lexical é importante aqui.Ver esta resposta para uma melhor explicação.

Quais coisas são proibidas no modo estrito?

Achei um bom artigo descrevendo várias coisas que são proibidas no modo estrito (observe que esta não é uma lista exclusiva):

Escopo

Historicamente, o JavaScript está confuso sobre como as funções são escopo.Às vezes, eles parecem estar estaticamente escopo, mas alguns recursos os fazem se comportar como se fossem dinamicamente escopo.Isso é confuso, dificultando a leitura e a compreensão dos programas.Mal-entendidos causam bugs.Também é um problema de desempenho.O escopo estático permitiria que a ligação variável ocorresse no tempo de compilação, mas o requisito de escopo dinâmico significa que a ligação deve ser adiada para o tempo de execução, o que vem com uma penalidade de desempenho significativa.

O modo estrito requer que todas as ligações de variáveis ​​sejam feitas estaticamente.Isso significa que os recursos que exigiam anteriormente a ligação dinâmica devem ser eliminados ou modificados.Especificamente, a declaração com com a capacidade de adulteração do ambiente de seu chamador é severamente restrita.

Um dos benefícios do código estrito é que ferramentas como Compressor YUIpode fazer um trabalho melhor ao processá-lo.

Variáveis ​​Globais Implícitas

JavaScript implica variáveis ​​globais.Se você não declarar explicitamente uma variável, uma variável global será declarada implicitamente para você.Isso facilita a programação para iniciantes, porque eles podem negligenciar algumas de suas tarefas básicas de limpeza.Mas isso torna o gerenciamento de programas maiores muito mais difícil e degrada significativamente a confiabilidade.Portanto, no modo rigoroso, as variáveis ​​globais implícitas não são mais criadas.Você deve declarar explicitamente todas as suas variáveis.

Vazamento Global

Existem diversas situações que podem causar thispara ser vinculado ao objeto global.Por exemplo, se você esquecer de fornecer o new prefixo ao chamar uma função construtora, o construtor this estará vinculado inesperadamente ao objeto global; portanto, em vez de inicializar um novo objeto, ele estará adulterando silenciosamente com variáveis ​​globais.Nessas situações, o modo rigoroso vinculará this para undefined, o que fará com que o construtor jogue uma exceção, permitindo que o erro seja detectado muito mais cedo.

Falha Barulhenta

JavaScript sempre teve propriedades somente leitura, mas você não pode criá-las até o ES5's Object.createPropertyfunção expôs essa capacidade.Se você tentasse atribuir um valor a uma propriedade somente leitura, ela falharia em silêncio.A tarefa não alteraria o valor da propriedade, mas seu programa prosseguiria como se tivesse.Este é um risco de integridade que pode fazer com que os programas entrem em um estado inconsistente.No modo rigoroso, tentar alterar uma propriedade somente leitura lançará uma exceção.

octal

A representação octal (ou base 8) dos números foi extremamente útil ao fazer programação no nível da máquina em máquinas cujos tamanhos de palavras eram um múltiplo de 3.Você precisava de octal ao trabalhar com o mainframe do CDC 6600, que tinha um tamanho de palavra de 60 bits.Se você pudesse ler Octal, poderá olhar para uma palavra como 20 dígitos.Dois dígitos representaram o código OP e um dígito identificou um dos 8 registros.Durante a transição lenta dos códigos da máquina para as linguagens de alto nível, considerou -se útil fornecer formulários octais nas linguagens de programação.

Em C, foi selecionada uma representação extremamente infeliz da octalidade:Zero à esquerda.Então em C, 0100 significa 64, não 100, e 08 é um erro, não 8.Infelizmente, ainda mais, esse anacronismo foi copiado em quase todos os idiomas modernos, incluindo JavaScript, onde é usado apenas para criar erros.Não tem outro propósito.Portanto, no modo rigoroso, os formulários octal não são mais permitidos.

Et cetera

Os argumentos pseudo-matriz se tornam um pouco mais parecidos com a matriz no ES5.No modo estrito, ele perde sua callee e callerpropriedades.Isto torna possível passar o seu arguments ao código não confiável sem desistir de muito contexto confidencial.Também o arguments propriedade das funções é eliminada.

No modo rigoroso, as teclas duplicadas em uma função literal produzirão um erro de sintaxe.Uma função não pode ter dois parâmetros com o mesmo nome.Uma função não pode ter uma variável com o mesmo nome que um de seus parâmetros.Uma função não pode delete suas próprias variáveis.Uma tentativa de delete uma propriedade não configurável agora gera uma exceção.Os valores primitivos não são implicitamente embrulhados.

Palavras reservadas para futuras versões de JavaScript

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

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

Leitura adicional

Eu recomendo fortemente todo desenvolvedor para começar a usar o modo rigoroso agora. Existem navegadores suficientes que apoiam que o modo rigoroso ajudará legitimamente a salvar -nos de 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 fazer testes adequados depois de mudar para o modo rigoroso para garantir que pegamos tudo. Definitivamente não jogamos apenas use strict Em nosso código e assuma que não há erros. Portanto, 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 colar em seu script e ele examinará rapidamente quaisquer problemas e erros perceptíveis no seu código.

Gostaria de oferecer uma resposta um pouco mais fundamentada, complementando as outras respostas.Eu esperava editar a resposta mais popular, mas falhei.Tentei torná-lo o mais abrangente e completo possível.

Você pode consultar o Documentação MDN Para maiores informações.

"use strict" uma diretiva introduzida no ECMAScript 5.

As diretivas são semelhantes às declarações, mas diferentes.

  • use strict não contém palavras-chave:A diretiva é uma declaração de expressão simples, que consiste em uma string literal especial (entre aspas simples ou duplas).Os mecanismos JavaScript, que não implementam ECMAScript 5, apenas veem uma instrução de expressão sem efeitos colaterais.Espera-se que versões futuras dos padrões ECMAScript introduzam use como uma verdadeira palavra-chave;as cotações se tornariam obsoletas.
  • use strict pode ser usado apenas no início de um script ou de uma função, ou seja,deve preceder qualquer outra declaração (real).Não precisa ser a primeira instrução em um script de função:pode ser precedido por outras expressões de instrução que consistem em literais de string (e as implementações de JavaScript podem tratá-las como diretivas específicas de implementação).Instruções literais de string, que seguem uma primeira instrução real (em um script ou função) são instruções de expressão simples.Os intérpretes não devem interpretá-las como directivas e não têm qualquer efeito.

O use strict A diretiva 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 de um script (código que não está em uma função) é considerado código estrito quando o script contém um use strict directiva.O conteúdo de uma função é considerado código estrito quando a própria função é definida em um código estrito ou quando a função contém um código estrito. use strict directiva.Código que é passado para um eval() método é considerado código estrito quando eval() foi chamado a partir de um código estrito ou contém o use strict própria directiva.

O modo estrito do ECMAScript 5 é um subconjunto restrito da linguagem JavaScript, que elimina déficits relevantes da linguagem e apresenta verificação de erros mais rigorosa e maior segurança.A seguir listamos 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 usar o with-instrução em modo estrito.
  • No modo estrito todas as variáveis ​​devem ser declaradas:se você atribuir um valor a um identificador que não foi declarado como variável, função, parâmetro de função, parâmetro de cláusula catch ou propriedade do global Object, então você receberá um ReferenceError.No modo normal, o identificador é declarado implicitamente como uma variável global (como uma propriedade do global Object)
  • No modo estrito, a palavra-chave this tem o valor undefined em funções que foram invocadas como funções (não como métodos).(No modo normal this sempre aponta para o mundo Object).Essa diferença pode ser usada para testar se uma implementação suporta o modo estrito:
var hasStrictMode = (function() { "use strict"; return this===undefined }());

  • Além disso, quando uma função é invocada com call() ou apply no modo estrito, então this é exatamente o valor do primeiro argumento do call()ou apply() invocação.(No modo normal null e undefined são substituídos pelo mundo Object e valores, que não são objetos, são convertidos em objetos.)

  • No modo estrito você obterá um TypeError, quando você tenta atribuir propriedades somente leitura ou definir novas propriedades para um objeto não extensível.(No modo normal, ambos simplesmente falham sem mensagem de erro.)

  • No modo estrito, ao passar código para eval(), você não poderá declarar ou definir variáveis ​​ou funções no escopo do chamador (como você pode fazer no modo normal).Em vez disso, um novo escopo é criado para eval() e as variáveis ​​e funções estão dentro desse escopo.Esse escopo é destruído após eval() termina a execução.
  • No modo estrito, o objeto de argumentos de uma função contém uma cópia estática dos valores, que são passados ​​para essa função.No modo normal, o objeto argumentos tem um comportamento um tanto "mágico":Os elementos da matriz e os parâmetros da função nomeada fazem referência ao mesmo valor.
  • No modo estrito você obterá um SyntaxError quando o delete operador é seguido por um identificador não qualificado (uma variável, função ou parâmetro de função).No modo normal o delete expressão não faria nada e é avaliada como false.
  • No modo estrito você obterá um TypeError quando você tenta excluir uma propriedade não configurável.(No modo normal, a tentativa simplesmente falha e o delete expressão é avaliada para false).
  • No modo estrito é considerado um erro sintático quando se tenta definir diversas propriedades com o mesmo nome para um objeto literal.(No modo normal não há erro.)
  • No modo estrito é considerado um erro sintático quando uma declaração de função possui vários parâmetros com o mesmo nome.(No modo normal não há erro.)
  • No modo estrito, literais octais não são permitidos (estes são literais que começam com 0x.(No modo normal, algumas implementações permitem literais octais.)
  • No modo estrito, os identificadores eval e arguments são tratados como palavras-chave.Você não pode alterar seu valor, não pode atribuir um valor a eles e não pode usá-los como nomes para variáveis, funções, parâmetros de função ou identificadores de um bloco catch.
  • No modo estrito há mais restrições nas possibilidades de examinar a pilha de chamadas. arguments.caller e arguments.callee Causar um TypeError em uma função em modo estrito.Além disso, algumas propriedades de chamadas e argumentos de funções em modo estrito causam um TypeError quando você tenta lê-los.

Meus dois centavos:

Um dos objetivos do modo rigoroso é permitir a depuração mais rápida de questões. Ajuda os desenvolvedores a lançar uma exceção quando ocorrem certas coisas erradas que podem causar um comportamento silencioso e estranho da sua página da web. No momento em que usamos use strict, o código lançará erros que ajudam o desenvolvedor a corrigi -lo com antecedência.

Poucas coisas importantes que aprendi depois de usar use strict :

Evita a declaração de variável 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);

Agora, este código cria nameoftree no escopo global que poderia ser acessado usando window.nameoftree. Quando implementarmos use strict O código lançaria erro.

ReferenceError não capturado: NameOftree não está definido

Amostra

Elimina with declaração :

with As declarações não podem ser minificadas usando ferramentas como Uglify-js. Eles também descontinuada e removido das futuras versões JavaScript.

Amostra

Evita duplicatas:

Quando temos uma propriedade duplicada, ela lança uma exceção

SyntaxError não capturado: Propriedade de dados duplicados em objeto literal não permitido no modo rigoroso

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

Há poucos mais, mas preciso obter mais conhecimento sobre isso.

Se você usar um navegador lançado no último ano ou mais, provavelmente suporta o modo rigoroso JavaScript. Somente os navegadores mais antigos antes do ECMAScript 5 se tornarem o padrão atual não o suporta.

As cotações em torno do comando garantem que o código ainda funcione em navegadores mais antigos também (embora as coisas que geram um erro de sintaxe no modo rigoroso geralmente causam apenas o script de alguma maneira difícil de detectar nesses navegadores mais antigos).

Ao adicionar "use strict";, os seguintes casos jogarão um Erro de sintaxe Antes da execução do script:

  • Pavimentando o caminho para futuras versões do ECMAScript, usando uma das palavras -chave recém -reservadas (em previsão para Ecmascript 6): implements, interface, let, package, private, protected, public, static, e yield.

  • Declarando função em blocos 

    if(a<b){ function f(){} }

  • Sintaxe octal 

    var n = 023;

  • this apontar para o objeto global.

     function f() {
      "use strict";
      this.a = 1;
 };
 f();

  • Declarando duas vezes o mesmo nome para um nome de propriedade em um objeto literal 

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

    Este não é mais o caso no Ecmascript 6 (Bug 1041128).

  • Declarando dois argumentos de função com o mesmo nome função 

    f(a, b, b){}

  • Definir um valor para uma variável não declarada

    function f(x){
   "use strict";
   var a = 12;
   b = a + x*35; // error!
}
f();

  • Usando delete em um nome de variável delete myVariable;

  • Usando eval ou arguments como variável ou nome de argumento da função

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

Fontes:

Modo rigoroso faz várias alterações na semântica normal de JavaScript:

  • Elimina alguns erros silenciosos de JavaScript alterando -os para lançar erros.

  • Corrigir erros que dificultam os motores JavaScript para executar otimizações.

  • Proíbe alguma sintaxe que provavelmente seja definida em versões futuras do ECMAScript.

Para mais informações Vistit Modo rigoroso- javascript

"Use rigoroso"; é um seguro que o programador não usará as propriedades soltas ou ruins do JavaScript. É um guia, assim como uma régua o ajudará a fazer linhas retas. "Use Strict" ajudará você a fazer "codificação direta".

Aqueles que preferem não usar os governantes para fazer suas linhas retas geralmente acabam nessas páginas pedindo a outras pessoas para depurar seu código.

Acredite em mim. A sobrecarga é insignificante em comparação com o código mal projetado. Doug Crockford, que é desenvolvedor sênior de JavaScript há vários anos, tem um post muito interessante aqui. Pessoalmente, gosto de voltar ao site dele o tempo todo para ter certeza de não esquecer minha boa prática.

A prática moderna de JavaScript deve sempre evocar o "usar rigoroso"; Pragma. A única razão pela qual o grupo ECMA tornou o modo "rigoroso" opcional é permitir o acesso de codificadores menos experientes ao JavaScript e dar tempo para se adaptar às novas e mais seguras práticas de codificação.

Incluindo use strict no início de todos os seus arquivos JavaScript confidenciais a partir deste ponto é uma pequena maneira de ser um programador JavaScript melhor e evitar que variáveis ​​aleatórias se tornem globais e as coisas mudem silenciosamente.

Citando w3schools:

A diretiva "uso estrito"

A diretiva "Use Strict" é nova em JavaScript 1.8.5 (ECMAScript versão 5).

Não é uma afirmação, mas uma expressão literal, ignorada pelas versões anteriores do JavaScript.

O objetivo de "Usar Strict" é indicar que o código deve ser executado no "modo rigoroso".

Com o modo estrito, você não pode, por exemplo, usar variáveis ​​não declaradas.

Por que modo estrito?

O modo estrito facilita a gravação de JavaScript "seguro".

O modo estrito transforma a "sintaxe incorreta" anteriormente aceita em erros reais.

Como exemplo, no JavaScript normal, a elogio de um nome variável cria uma nova variável global.No modo rigoroso, isso apresentará um erro, impossibilitando criar acidentalmente uma variável global.

No JavaScript normal, um desenvolvedor não receberá nenhum feedback de erro que atribua valores a propriedades não escritas.

No modo rigoroso, qualquer atribuição a uma propriedade não criada, uma propriedade somente getter, uma propriedade inexistente, uma variável inexistente ou um objeto inexistente, apresentará um erro.

Consulte http://www.w3schools.com/js/js_strict.asp Para saber mais

"use strict" faz com que o código JavaScript seja executado modo estrito, o que basicamente significa que tudo precisa ser definido antes do uso.A principal razão para usar o modo estrito é evitar usos globais acidentais de métodos indefinidos.

Também no modo estrito as coisas rodam mais rápido, alguns avisos ou avisos silenciosos geram erros fatais, é melhor usá-lo sempre para fazer um código mais organizado.

"use strict" é amplamente necessário para ser usado em ECMA5, no ECMA6 faz parte do JavaScript por padrão, portanto não precisa ser adicionado se você estiver usando ES6.

Veja estas declarações e exemplos do MDN:

A diretiva "uso estrito"
A diretiva "Use Strict" é nova em JavaScript 1.8.5 (ECMAScript versão 5).Não é uma afirmação, mas uma expressão literal, ignorada pelas versões anteriores do JavaScript.O objetivo de "Usar Strict" é indicar que o código deve ser executado no "modo rigoroso".Com o modo rigoroso, você não pode, por exemplo, usar variáveis ​​não declaradas.

Exemplos de uso de "use strict":
Modo estrito para funções:Da mesma forma, para invocar o modo rigoroso para uma função, coloque a afirmação exata "use rigoroso";(ou 'use rigoroso';) no corpo da função antes de quaisquer outras declarações.

1) modo estrito em funções 

 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 estrito de script inteiro 

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

3) Atribuição a um global não gravável

'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

Você pode leia mais no MDN.

Há uma boa conversa de algumas pessoas que estavam no comitê do ECMAScript: Alterações em JavaScript, Parte 1: Ecmascript 5 " sobre como o uso incremental do "use strict" O Switch permite que os implementadores do JavaScript limpem muitos dos recursos perigosos do JavaScript sem quebrar repentinamente todos os sites do mundo.

É claro que também fala sobre o que são muitas dessas malferações (foram) e como o ECMAScript 5 as corrige.

Pequenos exemplos para comparar:

Modo não rigoroso:

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

Modo estrito:

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

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

Modo não rigoroso:

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

Observe que use strict foi introduzido em Ecmascript 5 e foi mantido desde então.

Abaixo estão as condições para desencadear o modo rigoroso em ES6 e ES7:

  • O código global é o código de modo rigoroso se ele começar com um prólogo da diretiva que contém uma diretiva estrita de uso (consulte 14.1.1).
  • O código do módulo é sempre o código de modo rigoroso.
  • Todas as partes de um ClassDeclaration ou a Classexpressão são código de modo rigoroso.
  • O código de avaliação é o código de modo rigoroso se ele começar com um prólogo da diretiva que contém uma diretiva estrita de uso ou se a chamada para avaliar for uma avaliação direta (consulte 12.3.3.1) que está contida no código de modo rigoroso.
  • O código da função é código de modo rigoroso se o associado FunctionDeclaration, FunctionExpression, GeneratordEclaration, Generatorexpression, MethodDefinition ou Arrowfunção está contido no código do modo rigoroso ou se o código que produz o valor do slot interno [[ECMAScriptCode]] começa com um prólogo de diretiva que contém uma diretiva estrita de uso.
  • Código de função que é fornecido como argumentos para a função interna e os construtores de gerador é o código de modo rigoroso se o último argumento for uma string que quando processado for um Functionbody Isso começa com um prólogo de diretiva que contém uma diretiva estrita de uso.

As principais razões pelas quais os desenvolvedores devem usar "use strict" são:

  1. Impede a declaração acidental de variáveis ​​globais.Usando "use strict()" garantirá que as variáveis ​​sejam declaradas com var antes de usar.Por exemplo:

    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. Observação:O "use strict" A diretiva só é reconhecida no início de um script ou função.

  3. A corda "arguments" não pode ser usado como uma variável:

    "use strict";
var arguments = 3.14;    // This will cause an error

  4. Restringirá o uso de palavras-chave como variáveis.Tentar usá-los gerará erros.

Resumindo, tornará seu código menos sujeito a erros e, por sua vez, fará com que você escreva um bom código.

Para ler mais sobre isso você pode consultar aqui.

“usar estrito”;é o esforço da ECMA para tornar o JavaScript um pouco mais robusto.Traz no JS uma tentativa de torná-lo pelo menos um pouco "estrito" (outras linguagens implementam regras rígidas desde a década de 90).Na verdade, isso "força" os desenvolvedores de JavaScript a seguir algum tipo de prática recomendada de codificação.Ainda assim, o JavaScript é muito frágil.Não existem variáveis ​​digitadas, métodos digitados, etc.Eu recomendo fortemente que os desenvolvedores de JavaScript aprendam uma linguagem mais robusta, como Java ou ActionScript3, e implementem as mesmas práticas recomendadas em seu código JavaScript, pois funcionará melhor e será mais fácil de depurar.

O modo JavaScript "rigoroso" foi introduzido no ECMAScript 5.

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

Escrita "use strict"; Na parte superior do seu arquivo JS, lança verificação estrita de sintaxe. Faz as seguintes tarefas para nós:

  1. Mostra um erro se você tentar atribuir a uma variável não declarada

  2. impede você de substituir as principais bibliotecas do sistema JS

  3. proíbe alguns recursos de linguagem insegura ou propensa a erros

use strict também funciona dentro das funções individuais. É sempre uma prática melhor incluir use strict em seu código.

Problema de compatibilidade do navegador: as diretivas de "uso" devem ser compatíveis com versões anteriores. Os navegadores que não os suportam verão apenas uma corda literal que não é referenciada mais. Então, eles vão passar por cima e seguir em frente.

use strict é uma maneira de tornar seu código mais seguro, porque você não pode usar recursos perigosos que podem funcionar não como você espera. E como foi escritado antes que ele torne o código mais rigoroso.

Use Strict é usado para mostrar erros comuns e repetidos, para que seja tratado de maneira diferente e muda a maneira como o script Java é executado, essas mudanças são:

  • Evita globais acidentais

  • Sem duplicatas

  • Elimina com

  • Elimina essa coerção

  • Eval mais seguro ()

  • Erros para imutáveis

você também pode ler isso artigo Para os detalhes

Normalmente, o JavaScript não segue regras estritas, portanto, crescentes chances de erros. Depois de usar "use strict", o código JavaScript deve seguir o conjunto rigoroso de regras, como em outras linguagens de programação, como o uso de terminadores, a declaração antes da inicialização, etc.

Se "use strict" é usado, o código deve ser escrito seguindo um conjunto estrito de regras, diminuindo, portanto, as chances de erros e ambiguidades.

“usar estrito”;Define que o código JavaScript deve ser executado em "modo rigoroso".

  • A diretiva "use strict" era nova no ECMAScript versão 5.
  • Não é uma afirmação, mas uma expressão literal, ignorada pelas versões anteriores do JavaScript.
  • O objetivo de "Usar Strict" é indicar que o código deve ser executado no "modo rigoroso".
  • Com o modo estrito, você não pode, por exemplo, usar variáveis ​​não declaradas.

Todos os navegadores modernos suportam "use strict", exceto Internet Explorer 9 e inferior.

Desvantagem

Se um desenvolvedor usasse uma biblioteca que estava em modo estrito, mas estivesse acostumado a trabalhar em modo normal, ele poderia chamar algumas ações na biblioteca que não funcionariam conforme o esperado.

Pior ainda, como o desenvolvedor está no modo normal, ele não tem as vantagens de erros extras serem lançados, então o erro pode falhar silenciosamente.

Além disso, conforme listado acima, o modo estrito impede que você faça certas coisas.

As pessoas geralmente pensam que você não deveria usar essas coisas em primeiro lugar, mas alguns desenvolvedores não gostam da restrição e querem usar todos os recursos da linguagem.

O modo rigoroso pode impedir vazamentos de memória.

Verifique a função abaixo escrita no modo não rito:

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

Nesta função, estamos usando uma variável chamada name dentro da função. Internamente, o compilador verificará primeiro se houver alguma variável declarada com esse nome específico nesse escopo de função específico. Como o compilador entendeu que não existe essa variável, ele verificará o escopo externo. No nosso caso, é o escopo global. Novamente, o compilador entendeu que também não há variável declarada no espaço global com esse nome, por isso cria uma variável para nós no espaço global. Conceitualmente, essa variável será criada no escopo global e estará disponível em todo o aplicativo.

Outro cenário é que, digamos, a variável é declarada em uma função infantil. Nesse caso, o compilador verifica a validade dessa variável no escopo externo, ou seja, a função pai. Somente então ele verificará o espaço global e criará uma variável para nós lá. Isso significa que verificações adicionais precisam ser feitas. Isso afetará o desempenho do aplicativo.

Agora vamos escrever a mesma função no modo rigoroso.

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

Vamos receber o seguinte erro.

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

Aqui, o compilador lança o erro de referência. No modo rigoroso, o compilador não nos permite usar a variável sem declará -la. Portanto, vazamentos de memória podem ser evitados. Além disso, podemos escrever um código mais otimizado.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top