É apenas um texto que você coloca em seus arquivos JavaScript (tanto no topo de seu arquivo ou dentro de uma função) que se parece com isso:

"use strict";

A instrução {[[0]} instrui o navegador a usar o modo estrito, que é um conjunto de funcionalidades reduzido e mais seguro do JavaScript.

Lista das características (não exaustiva)

1. Desautoriza variáveis globais. (Capturas em falta var declarações e tipos de caracteres em nomes variáveis)

2. A falha silenciosa das atribuições irá criar um erro no modo estrito (atribuir NaN = 5;)

3. As tentativas de apagar propriedades não-negociáveis irão disparar (delete Object.prototype)

4. Exige que todos os nomes de propriedades num objecto literal sejam únicos (var x = {x1: "1", x1: "2"})

5. Os nomes dos parâmetros das funções devem ser únicos (function sum (x, x) {...})

6. Proíbe a sintaxe octal (var x = 023; alguns devs assumem erradamente que um zero anterior não faz nada para alterar o número.)

7. Proíbe a palavra-chave with

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

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

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

11. Strict mode Não alias propriedades do objeto arguments com os parâmetros formais. (isto é, em function sum (a,b) { return arguments[0] + b;} isto funciona porque {[14] } Está ligado a a e assim por diante. )

12. arguments.callee não é suportado

[Ref: modo estrito, rede de desenvolvimento do Mozilla]

Se as pessoas estão preocupadas com o uso use strict pode valer a pena verificar este artigo:

ECMAScript 5' Strict mode ' suporte em navegadores. O que significa isto??
NovoGeek.com -o weblog de Krishna.

Ele fala sobre suporte de navegador, mas mais importante, como lidar com ele 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 precaução, todos os programadores de carga dura: aplicar {[[0]} ao código existente pode ser perigoso! Esta coisa não é um autocolante que se sinta bem e feliz e que se possa pôr no código para o tornar "melhor". Com o {[[0]} pragma, o navegador irá De repente lançar exceções em locais aleatórios que ele nunca jogou antes só porque nesse ponto você está fazendo algo que o JavaScript padrão/solto felizmente permite, mas o JavaScript estrito abomina! Você pode ter violações de rigor escondendo - se em chamadas raramente usadas em seu código que só vai lançar uma exceção quando eles eventualmente começar run-say, no ambiente de produção que seus clientes pagantes usam!

Se você vai dar o salto, é uma boa ideia aplicar {[[[0]} a par de testes de unidade abrangentes e uma tarefa de construção JSHint rigorosamente configurada que lhe dará alguma confiança de que não há nenhum canto escuro do seu módulo que irá explodir horrivelmente só porque você ligou o Modo restrito. Ou ... , aqui está outra opção: apenas não adicione "use strict" a nenhum de seu código legado, provavelmente é mais seguro assim, honestamente. definitivamente não adicione "use strict" a quaisquer módulos que não possua ou mantenha, como módulos de terceiros.

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

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

'use strict';

Quando um motor JavaScript vê esta directiva, começará a interpretar o código num modo especial. Neste modo, erros são lançados quando certas práticas de codificação que podem acabar sendo bugs potenciais são detectadas. (que é o raciocínio por trás do modo estrito).

Considere este exemplo:

var a = 365;
var b = 030;

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

Onde devo usar 'use strict';?

• Na minha aplicação JavaScriptNova : absolutamente!O Modo restrito pode ser usado como denunciante quando se está a fazer algo estúpido com o código.

• No meucódigo JavaScript existente : provavelmente não! se o seu código JavaScript existente tem declarações que são proibidas em modo estrito, a aplicação irá simplesmente quebrar. Se quiser um modo rigoroso, deverá estar preparado para depurar e corrigir o seu código existente. É por isso que usar 'use strict'; de repente não torna o seu código melhor.

Como É Que Eu uso o modo restrito?

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

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

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

2. Ou, insira uma declaração 'use strict'; no topo do seu corpo funcional:

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

   Tudo no âmbito lexical da função doSomething será interpretado em modo estrito. A palavra "âmbito lexical" é importante aqui. Veja esta resposta para uma explicação melhor.

Encontrei um artigo bonito descrevendo várias coisas que são proibidas em modo estrito (note que esta não é uma lista exclusiva):

Âmbito de aplicação

Historicamente, o JavaScript tem estado confuso sobre como as funções estão a ser observados. Ora eles parecem ter escopo estático, mas alguns as características fazem com que se comportem como se fossem dinamicamente escopiados. Isto é ... confuso, tornando os programas difíceis de ler e entender. Mal-entendidos causam erros. Também é um problema para o desempenho. O escopo estático permitiria que a ligação variável acontecesse na compilação o tempo, mas o requisito para o âmbito dinâmico significa que a vinculação deve ser diferido para o tempo de execução, que vem com um desempenho significativo penalidade.

Modo restrito requer que todas as ligações variáveis sejam feitas de forma estática. Isso significa que as características que anteriormente necessitavam de ligação dinâmica deve ser eliminado ou modificado. Especificamente, a declaração com é eliminado, e a capacidade da função eval de manipular o o ambiente de quem ligou é muito restrito.

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

Global Implícito Variáveis

O JavaScript tem variáveis globais implícitas. Se você não declara explicitamente uma variável, uma variável global é implicitamente declarado por si. Isto torna a programação mais fácil para principiantes porque podem negligenciar algumas das suas tarefas domésticas básicas domestico. Mas isso torna a gestão de programas maiores muito mais difícil e degrada significativamente a confiabilidade. Tão em estrita mode, as variáveis globais implícitas já não são criadas. Devias. declarar explicitamente tudo das tuas variáveis.

Fuga Global

Há uma série de situações que podem causar ... estar ligado ao objecto global. Por exemplo, se se esquecer de indicar o prefixo new ao invocar uma função de construtor, o o construtor this será ligado inesperadamente ao objecto global, por isso ao invés de iniciar um novo objeto, ele será silenciosamente adulterar variáveis globais. Nestas situações, modo estrito em vez disso, ligar this a undefined, o que fará com que o construtor em vez disso, abra uma excepção, permitindo que o erro seja detectado muito cedo.

Falha Ruidosa

O JavaScript sempre teve propriedades apenas para leitura, mas tu ... não foi possível criá-los você mesmo até que ES5's Object.createProperty a função expôs essa capacidade. Se você tentou atribuir um valor para uma propriedade só de leitura, falharia silenciosamente. A missão não alterar o valor da propriedade, mas seu programa iria prosseguir como embora tivesse. Este é um risco de integridade que pode causar programas para entrar num estado inconsistente. Em modo estrito, a tentativa de alterar um a propriedade só de leitura abrirá uma excepção.

Octal

A representação octal (ou base 8) dos números era extremamente útil ao fazer programação de nível de máquina em máquinas cuja palavra os tamanhos eram um múltiplo de 3. Precisava de octal quando trabalhava com o CCD. 6600 mainframe, que tinha uma palavra de tamanho de 60 bits. Se pudesse ler octal, podes ver uma palavra como 20 dígitos. Dois dígitos representados o código de operação e um dígito identificaram um dos 8 registos. Durante a transição lenta de códigos de máquinas para línguas de alto nível, foi pensa-se ser útil para fornecer formas octais em linguagens de programação.

Em C, uma representação extremamente infeliz de octalness foi seleccionado: Zero inicial. Assim, em C, 0100 significa 64, não 100, e 08 é um erro, não 8. Ainda mais, infelizmente, isto o anacronismo tem sido copiado para quase todas as línguas modernas, incluindo JavaScript, onde ele só é usado para criar erros. Não tem outro propósito. Então em modo estrito, as formas octais não são mais Permitidas.

Et cetera

Os argumentos pseudo array torna-se um pouco mais matriz-como na ES5. Em modo estrito, perde o seu callee e caller propriedade. Isto torna possível passar o seu arguments para não ser de confiança. código sem abrir mão de muita confidencialidade contexto. Além disso, o arguments a propriedade das funções é eliminada.

Em modo estrito, teclas duplicadas num literal de função irão produzir 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 dos seus parametro. Uma função não pode {[25] } suas próprias variáveis. Uma tentativa de Uma propriedade não configurável abre agora uma excepção. Primitivo os valores não são implicitamente acondicionar.

Palavras reservadas para futuras versões JavaScript

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

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

Leitura Adicional

• Modo restrito-JavaScript | MDN
• Suporte do navegador para strict modo
• transição para o modo estrito

Recomendo vivamente que todos os programadores comecem a usar o modo estrito agora. Há navegadores suficientes apoiando-o que modo estrito vai legitimamente nos ajudar a salvar de erros que nem sabíamos que estavam em seu código.

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 vai rapidamente digitalizar quaisquer problemas perceptíveis e erros em seu código.

Pode consultar a documentaçãoMDN para mais informações.

"use strict" uma directiva introduzida no ECMAScript 5.

• use strict não contém palavras-chave: a Directiva é uma expressão simples, que consiste de uma cadeia especial literal (entre aspas simples ou duplas). Os motores JavaScript, que não implementam o ECMAScript 5, simplesmente vêem uma declaração de expressão sem efeitos colaterais. Espera-se que as futuras versões das normas ECMAScript introduzam use como uma palavra-chave real; As citações tornar-se-iam assim obsoletas.
• use strict só pode ser usado no início de um script ou de uma função, isto é, deve preceder todas as outras declarações (reais). Ele não tem que ser a primeira instrução em um script de função: ele pode ser precedido por outras expressões de declaração que consistem de string literals ( e implementações JavaScript podem tratá-los como diretivas específicas de implementação). Frases literais de texto, que seguem uma primeira instrução real (em um script ou função) são declarações de expressão simples. Os intérpretes não devem interpretá-las como directivas e não têm qualquer efeito.

A Directiva indica que a o código seguinte (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 função em si é 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 diretiva use strict si.

O modo estrito do ECMAScript 5 é um subconjunto restrito da linguagem JavaScript, o que elimina défices relevantes da linguagem e apresenta uma verificação de erros mais rigorosa e maior segurança. As seguintes listas das diferenças entre o modo estrito e o modo normal (das quais as três primeiras são particularmente importantes):

• Não pode usar a declaração with em modo estrito.
• em modo estrito todas as variáveis têm de ser declaradas: se atribuir um valor para um identificador que não tenha sido declarado como variável, função, parâmetro da função, parâmetro da cláusula de captura ou propriedade do global Object, então você terá um ReferenceError. No modo normal, o identificador é implicitamente declarado como uma variável global (como uma propriedade do global Object)
• em 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 {[15] } sempre aponta para o global Object). Esta diferença pode ser usado para testar se uma implementação suporta o modo estrito:

var hasStrictMode = (function() { "use strict"; return this===undefined }());

• Também quando uma função é invocada com call() ou apply em modo estrito, então this é exatamente o valor do primeiro argumento da invocação call()ou apply(). (No modo normal null e undefined são substituídos pelo global Object e os valores, que não são objectos, são lançados em objectos.)

• Em modo estrito você terá um TypeError, quando você tentar atribuir a propriedades readonly ou para definir novas propriedades para um objeto não extensível. (No modo normal ambos simplesmente falhar sem mensagem de erro.)

• em modo estrito, ao passar o código para eval(), Você não pode declarar ou definir variáveis ou funções no âmbito do chamador (como você pode fazê-lo 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 de eval() terminar a execução.
• em modo estrito, o arguments-object of a function contains a static copy of the values, which are passed to that function. No modo normal os argumentos-objeto tem um comportamento um tanto" mágico": os elementos da matriz e os parâmetros da função nomeados referenciam o mesmo valor.
• em Modo restrito, irá obter 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 delete não faria nada e é avaliado em false.
• em Modo restrito, irá obter um TypeError quando tentar apagar uma propriedade não configurável. (No modo normal a tentativa simplesmente falha e a expressão delete é avaliada em false).
• em modo estrito é considerado um erro sintático quando você tenta definir várias propriedades com o mesmo nome para um objeto literal. (No modo normal não há erro.)
• em modo estrito é considerado um erro sintático quando uma declaração de função tem múltiplos parâmetros com o mesmo nome. (No modo normal não há erro.)
• em modo estrito não são permitidos literais octais (estes são literais que começam com 0x. (In normal mode some implementations do allow octal literals.)
• em modo estrito, os identificadores eval e arguments são tratados como palavras-chave. Você não pode alterar o seu valor, não pode atribuir um valor a eles, e você não pode usá - los como nomes para variáveis, funções, parâmetros de função ou identificadores de uma captura bloco.
• em modo estrito há mais restrições sobre as possibilidades de examinar a pilha de chamadas. arguments.caller e arguments.callee causam a TypeError numa função em modo estrito. Além disso, algumas propriedades do chamador e argumentos de funções em modo estrito causam um TypeError quando você tenta lê - los.

Os meus dois cêntimos:

Evita A Variável Global Declaração:

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 âmbito global que pode ser acedido usando window.nameoftree. Quando implementarmos use strict o código iria lançar um erro.

ReferenceError não seleccionado: o nome da árvore não está definido

amostra

elimina a declaração with :

with as declarações não podem ser minificadas usando ferramentas como uglify-js. Também estão desactualizados. removido das versões futuras de JavaScript.

amostra

Evita Duplicados :

Erro Sintaxerror: propriedade de dados duplicada no objecto literal não permitido em modo estrito

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

Se você usar um navegador lançado no último ano ou assim, então ele provavelmente suporta JavaScript Strict mode. Apenas navegadores mais antigos em torno de ECMAScript 5 tornou-se o padrão atual não suporta.

As citações em torno 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 apenas causarão o problema do script de alguma forma difícil de detectar nesses navegadores mais antigos).

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

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

• Corrige erros que dificultam o JavaScript motores para realizar otimizações.

• Proíbe alguma sintaxe que possa ser definida no futuro versions of ECMAScript.

Para mais informações, vistit modo estrito-Javascript

Ao adicionar "use strict";, os seguintes casos irão lançar um SyntaxError antes de o programa estar a ser executado:

• preparando o caminho para o futuro ECMAScript versões, usando um dos recém-palavras reservadas (em previsão para ECMAScript 6): implements, interface, let, package, private, protected, public, static, e yield.

• Função de declaração em blocos

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

• Sintaxe Octal

  var n = 023;
  

• this aponta para o objecto 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 já não é o caso no ECMAScript 6 (bug 1041128).

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

  f(a, b, b){}
  

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

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

• Usar delete num nome de variável delete myVariable;

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

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

Fontes:

• Transição para o modo restrito no MDN

• Modo restrito no MDN

• Modo restrito do JavaScript e por que você deve usá-lo no blog de Colin J. Ihrig (versão arquivada)

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

Aqueles que preferem não usar governantes para fazer suas linhas direitas geralmente acabam nessas páginas pedindo que outros para depurar seu código.

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 codificadores menos experientes tenham acesso ao JavaScript e dar tempo para se adaptarem às novas e mais seguras práticas de codificação.

Incluindo use strict no início de todos os seus arquivos JavaScript sensíveis a partir deste ponto é uma pequena maneira de ser um melhor programador JavaScript e evitar variáveis aleatórias tornando-se global e as coisas mudam silenciosamente.

Citação de w3schools:

A Directiva" usar rigorosamente"

A Directiva" usar rigorosamente " é nova em JavaScript 1.8.5 (ECMAScript version 5).

Não é uma declaração, mas uma expressão literal, ignorada pelo anterior. versões de JavaScript.

O objectivo de" usar estritamente " é indicar que o código deve ser executado em "strict mode".

Com modo estrito, não pode, por exemplo, usar o não declarado variavel.

Porquê Modo Rigoroso?

O modo estrito torna mais fácil escrever JavaScript "seguro".

O modo estrito muda a "sintaxe má" anteriormente aceite para erros reais.

Como exemplo, em JavaScript normal, mistipar um nome de variável cria uma nova variável global. Em modo estrito, isto irá lançar um erro, tornando impossível criar acidentalmente uma variável global.

Em JavaScript normal, um programador não receberá nenhum erro feedback a atribuir valores a propriedades não passíveis de escrita.

Em modo estrito, qualquer atribuição a uma propriedade não registável, a propriedade getter-only, uma propriedade não existente, uma propriedade não existente variável, ou um objeto não-existente, irá lançar um erro.

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

Há um bom falar por algumas pessoas que estavam no ECMAScript comissão: Alterações para o JavaScript, Parte 1: ECMAScript 5" sobre como incremental uso do "use strict" switch permite que o JavaScript implementadores para limpar um monte de perigoso recursos de JavaScript sem, de repente, quebrando todos os sites do mundo.

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

Também em modo estrito, as coisas correm mais rápido, alguns avisos ou avisos silenciosos lançam erros fatais, é melhor sempre usá-lo para fazer um código mais limpo.

"use strict" é amplamente necessário para ser usado em ECMA5, em ECMA6 é parte de JavaScript por por omissão , por isso não precisa de ser adicionado se estiver a usar o ES6.

Veja estas declarações e exemplos da MDN:

A Directiva" usar rigorosamente"
a Directiva" usar rigorosamente " é nova em JavaScript 1.8.5 (ECMAScript version 5). Não é uma declaração, mas uma expressão literal, ignorada por versões anteriores do JavaScript. O o objectivo da "utilização estrita" é indicar que o código deve ser executado em "strict mode". Com o modo estrito, você não pode, para exemplo, utilizar variáveis não declaradas.

Exemplos de utilização de "usar estritamente":
Modo estrito para funções: da mesma forma, para invocar modo estrito para um função, colocar a indicação exata "use strict"; (ou' use strict';) em o corpo da função antes de quaisquer outras declarações.

1) modo estrito nas 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 programa completo

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

3) atribuição a uma pasta sem escrita 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

Você podeler mais sobre MDN .

Note que use strict foi introduzido emEcmaScript 5 e foi mantido desde então.

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

• o código Global é um código de modo estrito se começar por um prólogo de directiva que contém uma directiva de Utilização estrita (ver 14.1.1).
• O Código do módulo é sempre o código de modo estrito.
• todas as partes de uma Classdeclaração ou a ClassExpression são rigorosas. código do modo.
• o código Eval é um código de modo estrito se começa com um prólogo de directiva que contém uma directiva de uso estrito ou se a chamada para eval é um eval direto (Ver 12.3.4.1) que está contido em código de modo estrito.
• código de Função é de modo estrito código se o associado FunctionDeclaration, FunctionExpression, GeneratorDeclaration, GeneratorExpression, MethodDefinition, ou ArrowFunction está contido em modo estrito código ou se o código que produz o o valor da ranhura interna da função [[ECMAScriptCode]] começa com um prólogo de diretiva que contém uma diretiva de uso estrito.
• o código da função que é fornecido como os argumentos para a função incorporada e construtores de geradores é um código de modo estrito se o último argumento é uma cadeia que, quando processado é um FunctionBody que começa com um prólogo de directiva que contém uma directiva de uso estrito.

Pequeno exemplo para comparar:

Modo Não-rigoroso:

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

// output:
// 1
// 2
// 3

Modo restrito:

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

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

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

1. Impede a declaração acidental de variáveis globais.A utilização de "use strict()" assegurará que as variáveis são declaradas com var antes da utilização. Eg:

   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. n. B: a Directiva "use strict" só é reconhecida no início de uma escrita ou de uma função.

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

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

4. Irá restringir os usos de palavras-chave como variáveis. A tentar usá-los vai lançar erros.

Para ler mais sobre ele você pode se referir aqui .

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 escrito antes, torna o código mais rigoroso.

"use strict"; é o esforço ECMA para tornar o JavaScript um pouco mais robusto. Ele traz em JS uma tentativa de torná-lo pelo menos um pouco "estrito" (outras línguas implementam regras estritas desde os anos 90). Na verdade," obriga " Desenvolvedores JavaScript a seguir algum tipo de codificação de melhores práticas. Ainda assim, o JavaScript é muito frágil. Não existe tal coisa como variáveis tipadas, métodos tipados, etc. Eu recomendo fortemente Desenvolvedores JavaScript para aprender uma linguagem mais robusta, como Java ou ActionScript3, e implementar as mesmas melhores práticas em seu código JavaScript, ele vai funcionar melhor e ser mais fácil de depurar.

O uso do Strict é usado para mostrar erros comuns e repetidos de modo a que seja tratado de forma diferente, e altera a forma como o programa java funciona, tais alterações são:

• Evita os globais acidentais

• Sem duplicados

• Elimina com

• Elimina esta coerção

• Avaliação mais segura()

• Erros para imutáveis

Também pode ler este Artigo para mais detalhes

Normalmente o java script não segue regras estritas, aumentando assim as chances de erros. Depois de usar "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 utilizado, então o código deve ser escrito seguindo um rigoroso conjunto de regras, diminuindo assim as hipóteses de erros e ambiguidades.

JavaScript" strict " mode introduz no ECMAScript 5.

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

Escrever "usar estritamente"; no topo do seu ficheiro JS liga estritamente verificação de sintaxe. Ele faz as seguintes tarefas para nós:

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

(ii) impede-o de substituir as bibliotecas-chave do sistema JS

(ii) proíbe algumas funcionalidades de linguagem inseguras ou propensas a erros

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

Problema De Compatibilidade Do Navegador: As directivas" utilização " destinam-se a ser compatíveis com o passado. Navegadores que não os suportam apenas verão um texto literal que não é mais referenciado. Então, eles vão passar por cima dele e seguir em frente.