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




nodejs pra (21)

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

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

Fazendo alguma pesquisa, percebi que algumas pessoas adicionam "use strict"; em seu código JavaScript. Depois que adicionei a declaraçã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"; tudo sobre o que isso implica, e ainda é relevante?

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


Answers

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

  1. Impede a declaração acidental de variáveis ​​globais . O uso "use strict()"garantirá que as variáveis ​​sejam declaradas varantes do uso. 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. Nota: A "use strict"diretiva é reconhecida apenas no início de um script ou de uma função.
  3. A string "arguments"não pode ser usada como uma variável:

    "use strict";
    var arguments = 3.14;    // This will cause an error
    
  4. Irá restringir o uso de palavras-chave como variáveis. Tentar usá-los causará erros.

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

Para ler mais sobre isso, você pode se referir aqui .


"Use Strict"; é um seguro que o programador não usará as propriedades soltas ou ruins do JavaScript. É um guia, assim como uma régua ajudará você a fazer linhas retas. "Use Strict" irá ajudá-lo a fazer "Straight coding".

Aqueles que preferem não usar réguas para fazer suas linhas normalmente acabam nas páginas pedindo que os outros depurem o 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, eu gosto de voltar ao seu site o tempo todo para me certificar de que não me esqueço da minha boa prática.

A prática moderna de JavaScript deve sempre evocar o "Use Strict"; pragma. A única razão pela qual o Grupo ECMA tornou o modo "Estrito" opcional é permitir que os codificadores menos experientes acessem o JavaScript e dar tempo de adaptação às novas e mais seguras práticas de codificação.


Ao adicionar "use strict"; , os casos a seguir lançarão um SyntaxError antes de o script ser executado:

  • Pavimentando o caminho para futuras versões ECMAScript , usando uma das palavras-chave recém-reservados (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 literal de objeto

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

    Este não é mais o caso no ECMAScript 6 ( bug 1041128 ).

  • Declarando dois argumentos de função com a mesma função de nome

    f(a, b, b){}
    
  • Definindo um valor para uma variável não declarada

    function f(x){
       "use strict";
       var a = 12;
       b = a + x*35; // error!
    }
    f();
    
  • Usando deleteem um nome de variáveldelete myVariable;

  • Usando evalou argumentscomo variável ou função nome do argumento

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

Fontes:


Incluir use strictno início de todos os seus arquivos JavaScript sensíveis 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.


Citação de w3schools :

A diretiva "use strict"

A diretiva "use strict" é nova no JavaScript 1.8.5 (ECMAScript versão 5).

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

O propósito de "usar estrito" é indicar que o código deve ser executado em "modo estrito".

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 altera a "sintaxe incorreta" anteriormente aceita em erros reais.

Como exemplo, no JavaScript normal, digitar incorretamente um nome de variável cria uma nova variável global. No modo estrito, isso gerará um erro, impossibilitando a criação acidental de uma variável global.

No JavaScript normal, um desenvolvedor não receberá nenhum feedback de erro atribuindo valores a propriedades não graváveis.

No modo estrito, qualquer atribuição a uma propriedade não gravável, uma propriedade somente de leitura, uma propriedade não existente, uma variável não existente ou um objeto não existente, lançará um erro.

Por favor, consulte http://www.w3schools.com/js/js_strict.asp para saber mais


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

O modo estrito de JavaScript é um recurso no ECMAScript 5 . Você pode ativar o modo estrito declarando isso no topo do seu script / função.

'use strict';

Quando um mecanismo JavaScript vê essa diretiva , ela começa a interpretar o código em um modo especial. Neste modo, os erros são gerados quando certas práticas de codificação que podem acabar sendo possíveis erros 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 de alinhar os literais numéricos, o desenvolvedor inadvertidamente inicializou 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 emitirá um erro.

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

Onde devo usar 'use strict'; ?

  • Na minha nova aplicação JavaScript: Absolutamente! O modo estrito pode ser usado como um denunciante quando você está fazendo algo estúpido com o seu código.

  • No meu código JavaScript existente : provavelmente não! Se o seu código JavaScript existente tiver instruções proibidas no modo estrito, o aplicativo simplesmente será interrompido. Se você quiser o modo estrito, você deve estar preparado para depurar e corrigir seu código existente. É por isso que usamos 'use strict'; não faz de repente seu código melhor .

Como eu uso o modo estrito?

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

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

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

  2. Ou insira um 'use strict'; declaração no topo do seu corpo de função:

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

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

Quais coisas são proibidas no modo estrito?

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

Escopo

Historicamente, o JavaScript ficou confuso sobre como as funções são definidas. Às vezes, eles parecem ter um escopo estatístico, mas alguns recursos fazem com que eles se comportem como se tivessem um escopo dinâmico. Isso é confuso, tornando os programas difíceis de ler e entender. Mal-entendido causa erros. Também é um problema de desempenho. O escopo estático permitiria que a vinculação de variáveis ​​acontecesse em tempo de compilação, mas o requisito para escopo dinâmico significa que a vinculação deve ser adiada para o tempo de execução, o que vem com uma penalidade de desempenho significativa.

O modo estrito requer que toda a ligação variável seja feita estaticamente. Isso significa que os recursos que anteriormente exigiam a vinculação dinâmica devem ser eliminados ou modificados. Especificamente, a instrução with é eliminada e a capacidade da função eval de adulterar o ambiente de seu chamador é severamente restrita.

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

Variáveis ​​Globais Implícitas

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

Vazamento Global

Há várias situações que podem fazer com que this seja vinculado ao objeto global. Por exemplo, se você esquecer de fornecer o new prefixo ao chamar uma função construtora, a do construtor será vinculada inesperadamente ao objeto global; assim, em vez de inicializar um novo objeto, ele estará silenciosamente interferindo nas variáveis ​​globais. Nessas situações, o modo estrito, em vez disso, ligará this a undefined , o que fará com que o construtor lance uma exceção, permitindo que o erro seja detectado muito mais cedo.

Falha ruidosa

O JavaScript sempre teve propriedades somente leitura, mas você não pode criá-las sozinho até que a função Object.createProperty do ES5 Object.createProperty essa capacidade. Se você tentou atribuir um valor a uma propriedade somente leitura, ele falharia silenciosamente. A atribuição não alteraria o valor da propriedade, mas seu programa continuaria como se tivesse. Esse é um risco de integridade que pode fazer com que os programas entrem em um estado inconsistente. No modo estrito, 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 em nível de máquina em máquinas cujo tamanho de palavra era um múltiplo de 3. Você precisava octal ao trabalhar com o mainframe CDC 6600, que tinha um tamanho de palavra de 60 bits. Se você pudesse ler octal, poderia ver uma palavra com 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 de máquina para linguagens de alto nível, acreditava-se ser útil fornecer formulários octal nas linguagens de programação.

Em C, uma representação extremamente desafortunada de octalness foi selecionada: Leading zero. Portanto, 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. Não tem outro propósito. Portanto, no modo estrito, os formulários octal não são mais permitidos.

Etcetera

O pseudo array de argumentos torna-se um pouco mais parecido com um array no ES5. No modo estrito, ele perde suas propriedades de caller e caller . Isso torna possível passar seus arguments para código não confiável sem abrir mão de muito contexto confidencial. Além disso, a propriedade arguments de funções é eliminada.

No modo estrito, as chaves duplicadas em um literal de função 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 de um dos 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 lança uma exceção. Valores primitivos não sã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 causará um erro. As palavras reservadas são:

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

Leitura Adicional


Meus dois centavos:

Um dos objetivos do modo estrito é permitir uma depuração mais rápida dos problemas. Ele ajuda os desenvolvedores lançando exceções quando ocorrem certas coisas erradas que podem causar um comportamento silencioso e estranho de sua página da web. No momento em que usamos use strict , o código descartará erros que ajudem o desenvolvedor a corrigi-lo antecipadamente.

Algumas coisas importantes que aprendi depois de usar o use strict :

Impede a Declaração Global de Variáveis:

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, esse código cria nameoftree no escopo global que pode ser acessado usando window.nameoftree . Quando implementamos o use strict o código lançaria um erro.

Desconhecido ReferenceError: nameoftree não está definido

Sample

Elimina with declaração:

with instruções não pode ser reduzido usando ferramentas como o uglify-js . Eles também estão deprecated e foram removidos de futuras versões do JavaScript.

Sample

Impede duplicatas:

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

Untaught SyntaxError: Propriedade de dados duplicada no literal do objeto não permitida no modo estrito

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

Há mais alguns, mas eu preciso ganhar mais conhecimento sobre isso.


Se você usa um navegador lançado no último ano, provavelmente ele é compatível com o modo JavaScript Strict. Apenas navegadores antigos antes do ECMAScript 5 se tornou o padrão atual, não o suportam.

As aspas ao redor do comando garantem que o código ainda funcionará em navegadores mais antigos (embora as coisas que geram um erro de sintaxe no modo estrito geralmente façam com que o script funcione mal em alguns desses navegadores mais antigos).


Eu recomendo fortemente que todo desenvolvedor comece a usar o modo estrito agora. Há um número suficiente de navegadores suportando esse modo estrito que legitimamente ajudará a nos salvar 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 alternar para o modo estrito para ter certeza de que capturamos tudo. Definitivamente não jogamos apenas o use strict em nosso código e assumimos 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 colar o seu script e ele procurará rapidamente por quaisquer problemas e erros visíveis no seu código.


Eu gostaria de oferecer uma resposta um pouco mais fundamentada, complementando as outras respostas. Eu estava esperando editar a resposta mais popular, mas falhei. Tentei torná-lo tão abrangente e completo quanto pude.

Você pode consultar a documentação do MDN para obter mais informações.

"use strict" uma diretiva introduzida no ECMAScript 5.

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 um literal de string especial (em aspas simples ou duplas). Mecanismos JavaScript, que não implementam ECMAScript 5, apenas veem uma declaração de expressão sem efeitos colaterais. Espera-se que futuras versões dos padrões ECMAScript introduzam o use como uma palavra-chave real; as cotações se tornariam obsoletas.
  • use strict pode ser usado somente no início de um script ou de uma função, ou seja, deve preceder todas as outras instruções (reais). Ele não precisa ser a primeira instrução em um script de função: ele pode ser precedido por outras expressões de instrução que consistem em literais de string (e implementações de JavaScript podem tratá-las como diretivas específicas de implementação). As 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á-los como diretivas e eles não têm efeito.

A diretiva use strict indica que o código a seguir (em um script ou uma 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 uma diretiva use strict . 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 uma diretiva use strict . O código que é passado para um método eval() é considerado código estrito quando eval() foi chamado de um código estrito ou contém a própria diretiva use strict .

O modo estrito do ECMAScript 5 é um subconjunto restrito da linguagem JavaScript, que elimina os déficits relevantes da linguagem e apresenta uma verificação de erros mais rigorosa e maior segurança. A seguir lista 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 comando -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 variável, função, parâmetro da função, parâmetro da cláusula catch ou propriedade do Object global, você receberá um ReferenceError . No modo normal, o identificador é implicitamente declarado como uma variável global (como uma propriedade do Object global)
  • No modo estrito, a palavra this chave this tem o valor undefined em funções que foram chamadas como funções (não como métodos). (No modo normal, this sempre aponta para o Object global). 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 é chamada com call() ou se apply no modo estrito, this é exatamente o valor do primeiro argumento da call() ou apply() . (No modo normal, null e undefined são substituídos pelo Object global e os valores, que não são objetos, são convertidos em objetos.)

  • No modo estrito, você receberá um TypeError , quando tentar atribuir a propriedades readonly 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 o código para eval() , você não pode 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 depois que eval() finaliza a execução.
  • No modo estrito, o objeto-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 nomeados fazem referência ao mesmo valor.
  • No modo estrito, você receberá um SyntaxError quando o operador delete for seguido por um identificador não qualificado (um parâmetro de variável, função ou função). No modo normal, a expressão de delete não faria nada e é avaliada como false .
  • No modo estrito, você receberá um TypeError quando tentar excluir uma propriedade não configurável. (No modo normal, a tentativa simplesmente falha e a expressão de delete é avaliada como false ).
  • No modo estrito, é considerado um erro sintático quando você tenta definir várias propriedades com o mesmo nome para um literal de objeto. (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 octal não são permitidos (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 sobre as possibilidades de examinar a pilha de chamadas. arguments.caller e arguments.callee causam um TypeError em uma função no modo estrito. Além disso, algumas propriedades de caller e argumentos de funções no modo estrito causam um TypeError quando você tenta lê-las.

O modo "estrito" de JavaScript é introduzido no ECMAScript 5.

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

escrevendo "use strict"; no topo do seu arquivo JS ativa a verificação de sintaxe estrita. Ele faz as seguintes tarefas para nós:

(i) mostra um erro se você tentar atribuir a uma variável não declarada

(ii) impede você de sobrescrever as principais bibliotecas do sistema JS

(ii) proíbe alguns recursos de linguagem inseguros ou propensos a erros

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

Problema de Compatibilidade do Navegador: As diretivas "use" devem ser compatíveis com versões anteriores. Os navegadores que não oferecem suporte a eles verão apenas um literal String que não é mais referenciado. Então, eles vão passar por cima e seguir em frente.


Normalmente, o script java não segue regras rígidas, aumentando assim as chances de erros. Após o uso "use strict", o código de script java deve seguir um conjunto estrito de regras, como em outras linguagens de programação, como o uso de terminadores, declaração antes da inicialização, etc.

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


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

  • Previne globals acidentais

  • Sem duplicatas

  • Elimina com

  • Elimina esta coerção

  • Safer mais seguro ()

  • Erros para imutables

Você também pode ler este article para os detalhes


Note que use strictfoi introduzido no EcmaScript 5 e foi mantido desde então.

Abaixo estão as condições para acionar o modo estrito no ES6 e ES7 :

  • O código global é um código de modo estrito se começar com um Prólogo da Diretiva que contenha uma Diretiva de Uso Rígido (ver 14.1.1).
  • O código do módulo é sempre código de modo estrito.
  • Todas as partes de um ClassDeclaration ou um ClassExpression são código de modo estrito.
  • O código Eval é um código de modo estrito se começar com um Prólogo de Diretiva que contenha uma Diretriz Restrita de Uso ou se a chamada para eval for um eval direto (ver 12.3.4.1) contido no código de modo estrito.
  • O código de função é um código de modo estrito se o FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition ou ArrowFunction associados estiver contido no código de modo estrito ou se o código que produz o valor do slot interno [[ECMAScriptCode]] da função começar com uma diretiva. que contém uma diretiva estrita de uso.
  • Código de função que é fornecido como os argumentos para os construtores internos de função e gerador é código de modo estrito se o último argumento é uma seqüência de caracteres que quando processada é um FunctionBody que começa com um prólogo de diretiva que contém uma diretiva de uso estrito.

Uma palavra de cautela, todos os programadores "use strict" : aplicar "use strict" ao código existente pode ser perigoso! Isso não é um adesivo de cara feliz que você pode colocar o código para torná-lo "melhor". Com o pragma "use strict" , o browser irá repentinamente EXPULSAR exceções em lugares aleatórios que ele nunca jogou antes, porque naquele local você está fazendo algo que o JavaScript padrão / frouxo permite alegremente, mas JavaScript abominável! Você pode ter violações de rigidez ocultas em chamadas raramente usadas em seu código que apenas lançarão uma exceção quando elas eventualmente forem executadas - por exemplo, no ambiente de produção que seus clientes pagantes usam!

Se você estiver indo para o mergulho, é uma boa idéia aplicar "use strict" juntamente com testes de unidade abrangentes e uma tarefa de construção JSHint estritamente configurada que lhe dará alguma confiança de que não há nenhum canto escuro de seu módulo que irá explodir horrivelmente só porque você ligou o modo estrito. Ou, ei, aqui está outra opção: apenas não adicione "use strict" a nenhum dos seus códigos legados, é provavelmente mais seguro assim, honestamente. DEFINITIVAMENTE NÃO adicione "use strict" a nenhum módulo que não possua ou mantenha, como módulos de terceiros.

Eu acho que mesmo que seja um animal mortalmente enjaulado, "use strict" pode ser bom, mas você tem que fazer certo. A melhor época para ir rigoroso é quando seu projeto é greenfield e você está começando do zero. Configure o JSHint/JSLint com todos os avisos e opções aumentados da maneira que sua equipe pode tolerar, obtenha um bom sistema de compilação / teste / afirmação du jour rigged como Grunt+Karma+Chai , e somente então comece marcando todos os seus novos módulos como "use strict" . Esteja preparado para curar muitos erros e avisos niggly. Certifique-se de que todos entendam a gravidade configurando a construção como FALHA se o JSHint/JSLint produzir alguma violação.

Meu projeto não era um projeto greenfield quando eu adotei "use strict" . Como resultado, meu IDE está cheio de marcas vermelhas porque não tenho "use strict" em metade dos meus módulos, e o JSHint reclama disso. É um lembrete para mim sobre o que eu deveria fazer no futuro. Meu objetivo é ser livre de marcas vermelhas devido a todas as minhas declarações "use strict" que estão faltando, mas isso está a anos de distância agora.


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

Para citar algumas partes interessantes:

O Strict Mode é um novo recurso do ECMAScript 5 que permite colocar um programa, ou uma função, em um contexto operacional "estrito". Esse contexto restrito impede que determinadas ações sejam tomadas e gera mais exceções.

E:

O modo estrito ajuda de duas maneiras:

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

Observe também que você pode aplicar "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ê tiver que misturar códigos antigos e novos ;-)

Então, suponho que seja um pouco como o "use strict" você pode usar no Perl (daí o nome?) : Ele ajuda você a fazer menos erros, detectando mais coisas que poderiam levar a quebras.

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


O modo estrito faz várias alterações na semântica normal do JavaScript:

  • elimina alguns erros silenciosos do JavaScript alterando-os para gerar erros.

  • Corrige erros que dificultam que os mecanismos JavaScript executem otimizações.

  • proíbe alguma sintaxe que possa ser definida em futuras versões do ECMAScript.

para mais informações vistit Strict Mode- Javascript


Há uma boa palestra de algumas pessoas que participaram do comitê do ECMAScript: Alterações no JavaScript, Parte 1: ECMAScript 5 " sobre como o uso incremental do "use strict"switch permite que os implementadores de JavaScript limpem muitos dos recursos perigosos do JavaScript sem interromper todos os sites no mundo.

É claro que também fala sobre o que são muitas dessas irregularidades e como o ECMAScript 5 as conserta.


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

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

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

Veja estas declarações e exemplos do MDN:

A diretiva
"use strict" A diretiva "use strict" é nova no JavaScript 1.8.5 (ECMAScript versão 5). Não é uma declaração, mas uma expressão literal, ignorada por versões anteriores do JavaScript. O propósito de "usar estrito" é indicar que o código deve ser executado em "modo estrito". Com o modo estrito, 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 estrito para uma função, coloque a instrução exata "use strict"; (ou 'use strict';) no corpo da função antes de qualquer outra declaração.

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 do 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 ler mais sobre o MDN .


Se as pessoas estão preocupadas com o use strict , vale a pena conferir este artigo:

ECMAScript 5 'Modo estrito' suporte em navegadores. O que isto significa?
NovoGeek.com - o blog de Krishna

Ele fala sobre o suporte ao navegador, mas, mais importante, como lidar com isso de maneira 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.
*/

Uma função em JavaScript não é apenas uma referência a um conjunto de instruções (como na linguagem C), mas também inclui uma estrutura de dados oculta que é composta de referências a todas as variáveis ​​não-locais que ele usa (variáveis ​​capturadas). Essas funções de duas peças são chamadas de fechamentos. Cada função em JavaScript pode ser considerada um encerramento.

Fechamentos são funções com um estado. É um pouco semelhante a "this" no sentido de que "this" também fornece estado para uma função, mas function e "this" são objetos separados ("this" é apenas um parâmetro sofisticado e a única maneira de vinculá-lo permanentemente a um função é criar um fechamento). Enquanto "this" e função sempre vivem separadamente, uma função não pode ser separada de seu fechamento e a linguagem não fornece meios para acessar variáveis ​​capturadas.

Como todas essas variáveis ​​externas referenciadas por uma função lexicalmente aninhada são, na verdade, variáveis ​​locais na cadeia de suas funções lexicamente delimitadoras (variáveis ​​globais podem ser consideradas variáveis ​​locais de alguma função raiz), e cada execução de uma função cria novas instâncias de Em suas variáveis ​​locais, toda execução de uma função retornando (ou transferindo-a de outra maneira, como registrá-la como um retorno de chamada) uma função aninhada cria um novo fechamento (com seu próprio conjunto de variáveis ​​não-locais referenciadas que representam sua execução) contexto).

Além disso, deve ser entendido que variáveis ​​locais em JavaScript são criadas não no quadro da pilha, mas no heap e destruídas somente quando ninguém as está referenciando. Quando uma função retorna, referências a suas variáveis ​​locais são decrementadas, mas elas ainda podem ser não nulas se durante a execução atual elas se tornarem parte de um encerramento e ainda forem referenciadas por suas funções aninhadas lexicalmente (o que pode acontecer somente se as referências a essas funções aninhadas foram retornadas ou transferidas para algum código externo).

Um exemplo:

function foo (initValue) {
   //This variable is not destroyed when the foo function exits.
   //It is 'captured' by the two nested functions returned below.
   var value = initValue;

   //Note that the two returned functions are created right now.
   //If the foo function is called again, it will return
   //new functions referencing a different 'value' variable.
   return {
       getValue: function () { return value; },
       setValue: function (newValue) { value = newValue; }
   }
}

function bar () {
    //foo sets its local variable 'value' to 5 and returns an object with
    //two functions still referencing that local variable
    var obj = foo(5);

    //Extracting functions just to show that no 'this' is involved here
    var getValue = obj.getValue;
    var setValue = obj.setValue;

    alert(getValue()); //Displays 5
    setValue(10);
    alert(getValue()); //Displays 10

    //At this point getValue and setValue functions are destroyed
    //(in reality they are destroyed at the next iteration of the garbage collector).
    //The local variable 'value' in the foo is no longer referenced by
    //anything and is destroyed too.
}

bar();






javascript syntax jslint use-strict