O modo rigoroso é um novo recurso do ECMAScript 5. Ele permite que você coloque todo o programa ou uma função, em um contexto de operação "rigoroso". Esse contexto estrito impede certas operações e lança mais exceções.
Embora o ECMAScript 5 seja compatível com o ECMAScript 3, no modo rigoroso, todos os recursos que não são favorecidos no Ecmascript 3 são desativados (ou lançados um erro) em vez de compatíveis.
Ativar o modo rigoroso tem os seguintes benefícios:
1. Pegue alguns erros de programação e faça exceções.
2. Evite que algumas operações relativamente "inseguras" (como acessar variáveis globais) sejam executadas e exceções são lançadas.
3. Desative alguns recursos confusos.
A maioria das informações sobre o modo rigoroso pode ser encontrado na página 223 do código ES5 [PDF].
(Nota: O modo estrito do ECMAScript 5 é diferente do modo estrito do Firefox)
Como ativar o modo rigoroso
Adicione esta declaração no início do programa para ativar o modo rigoroso para todo o script:
A cópia do código é a seguinte:
'Use rigoroso';
Você também pode ativar o modo rigoroso apenas dentro da função, para que ela não afete o exterior:
A cópia do código é a seguinte:
função imstritt () {
'Use rigoroso';
// ... seu código ...
}
Uma declaração que permite o modo rigoroso é apenas uma string normal "Use Strict", sem nenhuma nova sintaxe. Isso significa que não haverá impacto negativo no navegador antigo.
Uma aplicação prática de ativar o modo rigoroso dentro de uma função é definir toda a biblioteca da classe JavaScript dentro de uma função de modo rigoroso, para que não afete o código externo:
A cópia do código é a seguinte:
// Código não rito ...
(função(){
"Use rigoroso";
// Defina sua biblioteca estritamente ...
}) ();
// Código não rito ...
Então, quais mudanças foram feitas nos scripts no modo rigoroso?
Variáveis e propriedades
A atribuição de uma variável indefinida falhará em vez de usar essa variável como uma variável global.
Escrever uma propriedade com uma propriedade gravada falsa, excluindo uma propriedade com uma propriedade configurável com uma falsa ou adicionando uma propriedade com uma propriedade extensível com um falso, resultará em um erro (essas características são pré-contratadas). No passado, essas operações não jogavam exceções, mas simplesmente falharam em silêncio.
Executar operações de exclusão em variáveis, funções ou parâmetros de função causará um erro.
A cópia do código é a seguinte:
var foo = 'teste';
function test () {}
excluir foo; // erro
Excluir teste; // erro
função test2 (arg) {
excluir arg; // erro
}
Definir a mesma propriedade dentro de um contêiner de objeto fará com que a exceção seja lançada:
A cópia do código é a seguinte:
// erro
{foo: true, foo: false}
aval
Qualquer uso do nome "avaliar" (o principal objetivo é apontar a função de avaliação para uma variável ou propriedade de objeto) é proibida.
A cópia do código é a seguinte:
// todos geram erros ...
obj.eval = ...
obj.foo = avaliação;
var aval = ...;;
para (var avaliativo em ...) {}
function avaliar () {}
teste de função (avaliar) {}
função (avaliar) {}
nova função ("avaliação")
Além disso, a declaração de novas variáveis através da avaliação também será inválida:
A cópia do código é a seguinte:
Eval ("var a = false;");
impressão (tipo de A); // indefinido
função
Reescrever argumentos Objeto causará um erro:
A cópia do código é a seguinte:
argumentos = [...]; // não é permitido
Os parâmetros com o mesmo nome causarão um erro:
A cópia do código é a seguinte:
(function (foo, foo) {}) // erro
Acesso a argumentos.caller e argumentos.Callee lança uma exceção. Portanto, qualquer função anônima que precisa ser usada deve ser nomeada primeiro, por exemplo:
A cópia do código é a seguinte:
setTimeout (função posterior () {
// Faça coisas ...
setTimeout (mais tarde, 1000);
}, 1000);
Os argumentos, as propriedades do chamador e da Callee da função não existem mais, e a operação para defini -las também é proibida.
A cópia do código é a seguinte:
function test () {}
test.caller = 'chamador'; // erro
Finalmente, um bug de longa data (e muito irritante) foi resolvido: quando nulo ou indefinido é usado como o primeiro parâmetro da função.prototype.call ou function.prototype.Apply Método, esta dentro da função apontará para o objeto global. E o modo rigoroso impedirá sua execução e lançará exceções:
A cópia do código é a seguinte:
(function () {...}). Call (null); // exceção
com() { }
A instrução with () {} pendura completamente em modo rigoroso.