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

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?

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 function, 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 access ao object global).
  • Desativa resources 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 function 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) .

É um novo recurso do ECMAScript 5. John Resig escreveu um bom resumo dele.

É apenas uma string que você coloca em seus arquivos JavaScript (na parte superior do seu arquivo ou dentro de uma function) que se parece com isso:

 "use strict"; 

Colocá-lo em seu código agora não deve causar problemas com os navegadores atuais, pois é apenas uma string. Isso pode causar problemas com seu código no futuro se seu código violar o pragma. Por exemplo, se você atualmente tem 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 Strict, que é um conjunto de resources reduzido e seguro do JavaScript.

Lista de resources (não exaustivos)

  1. Não permite variables ​​globais. (Captura de declarações var e erros em nomes de variables)

  2. Atribuições de falha silenciosa lançarão erro no modo estrito (atribuindo NaN = 5; )

  3. Tentativas de excluir propriedades undeletable irão lançar ( delete Object.prototype )

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

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

  6. Proibe a syntax octal ( var x = 023; alguns desenvolvedores assumem erroneamente que um zero anterior não faz nada para alterar o número).

  7. Proíbe a palavra with chave with

  8. eval no modo estrito não introduz novas variables

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

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

  11. O modo estrito não alias propriedades do object de arguments com os parâmetros formais. (isto é, na function sum (a,b) { return arguments[0] + b;} Isso funciona porque os arguments[0] estão ligados a a e assim por diante.)

  12. arguments.callee não é suportado

[Ref: modo estrito , Mozilla Developer Network ]

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 palavra de caucanvas, 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 randoms 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 compilation / 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 objective é 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.

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

 '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 obsession 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 function:

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

    Tudo no escopo léxico da function 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 resources fazem com que eles se comportem como se tivessem um escopo dynamic. 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 variables ​​acontecesse em tempo de compilation, mas o requisito para escopo dynamic 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 binding variável seja feita estaticamente. Isso significa que os resources que anteriormente exigiam a vinculação dinâmica devem ser eliminados ou modificados. Especificamente, a instrução with é eliminada e a capacidade da function 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 variables ​​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 variables ​​globais implícitas não são mais criadas. Você deve declarar explicitamente todas as suas variables.

Vazamento Global

Há várias situações que podem fazer com que this seja vinculado ao object global. Por exemplo, se você esquecer de fornecer o new prefixo ao chamar uma function construtora, a do construtor será vinculada inesperadamente ao object global; assim, em vez de inicializar um novo object, ele estará silenciosamente interferindo nas variables ​​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 function 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 function produzirão um erro de syntax. Uma function não pode ter dois parâmetros com o mesmo nome. Uma function não pode ter uma variável com o mesmo nome de um dos seus parâmetros. Uma function não pode delete suas próprias variables. 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 variables ​​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

  • Modo Estrito – JavaScript | MDN
  • Suporte do navegador para o modo estrito
  • Transição para o modo estrito

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 function, ou seja, deve preceder todas as outras instruções (reais). Ele não precisa ser a primeira instrução em um script de function: 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 function) 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 function) é um código estrito. O código no nível mais alto de um script (código que não está em uma function) é considerado código estrito quando o script contém uma diretiva use strict . O conteúdo de uma function é considerado código estrito quando a própria function é definida em um código estrito ou quando a function 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 variables ​​devem ser declaradas: se você atribuir um valor a um identificador que não tenha sido declarado como variável, function, parâmetro da function, 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 methods). (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 function é 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 objects, são convertidos em objects.)

  • No modo estrito, você receberá um TypeError , quando tentar atribuir a propriedades readonly ou definir novas propriedades para um object 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 variables ​​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 variables ​​e funções estão dentro desse escopo. Esse escopo é destruído depois que eval() finaliza a execução.
  • No modo estrito, o object-argumentos de uma function contém uma cópia estática dos valores, que são passados ​​para essa function. No modo normal, o object-argumentos tem um comportamento um tanto “mágico”: os elementos da matriz e os parâmetros da function 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, function ou function). 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 object. (No modo normal não há erro.)
  • No modo estrito, é considerado um erro sintático quando uma declaração de function 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 variables, funções, parâmetros de function 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 function 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.

Meus dois centavos:

Um dos objectives do modo estrito é permitir uma debugging 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

Amostra

Elimina with declaração:

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

Amostra

Impede duplicatas:

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

Untaught SyntaxError: Propriedade de dados duplicada no literal do object 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 syntax no modo estrito geralmente façam com que o script funcione mal em alguns desses navegadores mais antigos).

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 syntax que possa ser definida em futuras versões do ECMAScript.

para mais informações vistit Strict Mode- Javascript

“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:

  • Paving the way for future ECMAScript versions , using one of the newly reserved keywords (in prevision for ECMAScript 6 ): implements , interface , let , package , private , protected , public , static , and yield .

  • Declaring function in blocks

     if(a 
  • Octal syntax

     var n = 023; 
  • this point to the global object.

      function f() { "use strict"; this.a = 1; }; f(); 
  • Declaring twice the same name for a property name in an object literal

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

    This is no longer the case in ECMAScript 6 ( bug 1041128 ).

  • Declaring two function arguments with the same name function

     f(a, b, b){} 
  • Setting a value to an undeclared variable

     function f(x){ "use strict"; var a = 12; b = a + x*35; // error! } f(); 
  • Using delete on a variable name delete myVariable;

  • Using eval or arguments as variable or function argument name

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

Sources:

  • Transitioning to strict mode on MDN

  • Strict mode on MDN

  • JavaScript's Strict Mode and Why You Should Use It on Colin J. Ihrig's blog (archived version)

Including use strict in the beginning of your all sensitive JavaScript files from this point is a small way to be a better JavaScript programmer and avoid random variables becoming global and things change silently.

Quoting from w3schools :

The “use strict” Directive

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

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

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

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

Why Strict Mode?

Strict mode makes it easier to write “secure” JavaScript.

Strict mode changes previously accepted “bad syntax” into real errors.

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

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

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

Please refer to http://www.w3schools.com/js/js_strict.asp to know more

There’s a good talk by some people who were on the ECMAScript committee: Changes to JavaScript, Part 1: ECMAScript 5″ about how incremental use of the "use strict" switch allows JavaScript implementers to clean up a lot of the dangerous features of JavaScript without suddenly breaking every website in the world.

Of course it also talks about just what a lot of those misfeatures are (were) and how ECMAScript 5 fixes them.

"use strict" makes JavaScript code to run in strict mode , which basically means everything needs to be defined before use. The main reason for using strict mode is to avoid accidental global uses of undefined methods.

Also in strict mode, things run faster, some warnings or silent warnings throw fatal errors, it’s better to always use it to make a neater code.

"use strict" is widely needed to be used in ECMA5, in ECMA6 it’s part of JavaScript by default , so it doesn’t need to be added if you’re using ES6.

Look at these statements and examples from MDN:

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

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

1) strict mode in functions

  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) whole-script strict mode

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

3) Assignment to a non-writable global

 '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 

You can read more on MDN .

Note that use strict was introduced in EcmaScript 5 and was kept since then.

Below are the conditions to trigger strict mode in ES6 and ES7 :

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

use strict is a way to make your code safer, cause you can’t use dangerous features which can work not as you expect.And as was writed before it makes code more strict.

“use strict”; is the ECMA effort to make JavaScript a little bit more robust. It brings in JS an attempt to make it at least a little “strict” (other languages implement strict rules since the 90s). It actually “forces” JavaScript developers to follow some sort of coding best practices. Still, JavaScript is very fragile. There is no such thing as typed variables, typed methods, etc. I strongly recommend JavaScript developers to learn a more robust language such as Java or ActionScript3, and implement the same best practices in your JavaScript code, it will work better and be easier to debug.

Small example to compare:

Non-strict mode:

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

Strict mode:

 'use strict'; for (i of [1,2,3]) console.log(i) // output: // Uncaught ReferenceError: i is not defined 

The main reasons why developers should use "use strict" are:

  1. Prevents accidental declaration of global variables.Using "use strict()" will make sure that variables are declared with var before use. 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. NB: The "use strict" directive is only recognized at the beginning of a script or a function.
  3. The string "arguments" cannot be used as a variable:

     "use strict"; var arguments = 3.14; // This will cause an error 
  4. Will restrict uses of keywords as variables. Trying to use them will throw errors.

In short will make your code less error prone and in turn will make you write good code.

To read more about it you can refer here .

Use Strict is used to show common and repeated errors so that it is handled differently , and changes the way java script runs , such changes are :

  • Prevents accidental globals

  • No duplicates

  • Eliminates with

  • Eliminates this coercion

  • Safer eval()

  • Errors for immutables

you can also read this article for the details

Normally java script does not follow strict rules hence increasing chances of errors. After using "use strict" , the java script code should follow strict set of rules as like in other programming languages such as use of terminators, declaration before initialization etc.

If "use strict" is used then the code should be written by following a strict set of rules hence decreasing the chances of errors and ambiguities.

JavaScript “strict” mode introduces in ECMAScript 5.

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

writing “use strict”; at the very top of your JS file turns on strict syntax checking. It does the following tasks for us :

(i) shows an error if you try to assign to an undeclared variable

(ii) stops you from overwriting key JS system libraries

(ii) forbids some unsafe or error-prone language features

“use strict” also works inside of individual functions. It is always a better practice to include “use strict in your code.

Browser Compatibility Issue: The “use” directives are meant to be backwards-compatible. Browsers that donot support them will just see a String literal that isn’t referenced further. So, they will pass over it and move on.