O padrão rigoroso introduzido no ECMAScript5 permite que os desenvolvedores tenham uma linguagem "melhor" JavaScript, permitindo que o ambiente de execução do JavaScript lide com alguns dos erros mais comuns e difíceis de detectar no processo de desenvolvimento. Por um longo tempo, tive dúvidas sobre o modo rigoroso, porque apenas o Firefox suporta o modo rigoroso. Hoje, porém, todos os navegadores principais suportam o modo rigoroso em suas versões mais recentes (incluindo IE10, Opera12 e Android 4, iOS5). É hora de começar a usar o modo rigoroso.
Qual o papel que o modelo rigoroso pode desempenhar?
O padrão rigoroso introduz muitas mudanças no JavaScript, e eu as dividi em duas categorias (óbvias e sutis). O objetivo de pequenas melhorias é corrigir alguns problemas detalhados no JavaScript atual, no qual não entrarei em profundidade aqui; Se você estiver interessado, leia o maravilhoso documento escrito por Dmitry Soshnikov ECMA-262-5 em detalhes Capítulo 2 Modo Estrito. Apresento principalmente as mudanças óbvias introduzidas pelo modo rigoroso, conceitos que você deve conhecer antes de usar o modo rigoroso e as alterações que mais ajudam você.
Antes de começar a aprender recursos específicos, lembre -se de que um dos principais objetivos do modo rigoroso é permitir que você depra mais rápido e conveniente. É melhor apresentar um erro explícito quando o ambiente de tempo de execução descobre um problema do que falhar silenciosamente ou agir de maneira estranha (o que geralmente é o caso dos ambientes de execução de JavaScript que não ativam o modo rigoroso). O modo rigoroso lança mais erros, mas isso é uma coisa boa, porque esses erros chamarão sua atenção e corrigem muitos problemas em potencial que antes eram difíceis de identificar.
Remova com palavras -chave
Primeiro, a instrução with é removida no modo rigoroso, e o código que contém a instrução com o com lançará uma exceção no modo rigoroso. Portanto, o primeiro passo para usar o modo rigoroso: verifique se você não usa no seu código.
A cópia do código é a seguinte:
// O código JavaScript a seguir lançará um erro no modo rigoroso
com (local) {
alerta (href);
}
Impedir que a atribuição inesperadamente valores a variáveis globais
Em segundo lugar, as variáveis locais devem ser declaradas antes da atribuição. Antes que o modo rigoroso seja ativado, uma variável global com o mesmo nome é criada automaticamente ao copiar para uma variável local não declarada. Esse é um dos erros mais comuns nos programas JavaScript e, ao tentar fazer isso no modo rigoroso, exceções explícitas serão lançadas.
A cópia do código é a seguinte:
// A exceção será lançada em modo rigoroso
(function () {
AlgumundeClaredvar = "Foo";
} ());
Isso na função não aponta mais para o global por padrão
Outra mudança importante no modo rigoroso é que essa função que não é definida ou indefinida (nula ou indefinida) não aponta para o ambiente global por padrão. Isso causará alguns erros de execução de código que dependem do comportamento padrão disso na função, por exemplo:
A cópia do código é a seguinte:
window.color = "vermelho";
function dizColor () {
alerta (this.color);
}
// Um erro será relatado no modo rigoroso. Se não estiver no modo rigoroso, ele levará "vermelho"
SayColor ();
// Um erro será relatado no modo rigoroso. Se não estiver no modo rigoroso, ele levará "vermelho"
SayColor.Call (NULL);
Isso permanecerá indefinido antes de ser atribuído, o que significa que, quando um construtor for executado, uma exceção será lançada se não houver uma nova palavra -chave clara antes.
A cópia do código é a seguinte:
Função Pessoa (nome) {
this.name = nome;
}
// haverá um erro no modo rigoroso
var Me = Pessoa ("Nicholas");
No código acima, porque não há novo antes, isso na função será deixado indefinido. Como você não pode definir propriedades para indefinição, o código acima lançará um erro. Em ambientes de modo não rígido, isso não é copiado para a variável global da janela por padrão, e o resultado da execução será inesperadamente definindo o atributo de nome para a variável global da janela.
Evite renomeamentos
Ao escrever muito código, as propriedades do objeto e os parâmetros de função são facilmente definidos acidentalmente como um nome duplicado. Modo rigoroso lançará explicitamente erros neste caso
A cópia do código é a seguinte:
// Nomes de variáveis repetidos relatarão um erro no modo rigoroso
função doSomething (value1, value2, value1) {
//código
}
// Nomes de atributos de objeto opaco relatarão um erro no modo rigoroso:
var object = {
Foo: "bar",
Foo: "Baz"
};
O código acima será considerado um erro de sintaxe no modo rigoroso e permitirá que você obtenha instruções antes da execução.
EVAL
Embora a instrução EVALL () não tenha sido removida no final, ela ainda foi melhorada no modo rigoroso. A maior mudança é que variáveis e declarações de funções executadas em avaliar () não criarão diretamente variáveis ou funções correspondentes no escopo atual, por exemplo:
A cópia do código é a seguinte:
(function () {
Eval ("var x = 10;");
// No modo não rito, alerta 10
// No modo rigoroso, uma exceção é lançada porque X não é definida.
alerta (x);
} ());
Quaisquer variáveis ou funções criadas durante a execução de avaliar () são retidas em Eval (). Mas você pode obter explicitamente o resultado da execução no EVAL () do valor de retorno da instrução EVALL (), por exemplo:
A cópia do código é a seguinte:
(function () {
var resultado = avaliar ("var x = 10, y = 20; x + y");
// As instruções restantes podem ser executadas corretamente no modo rigoroso ou não rigoroso. (Ressulst é 30)
alerta (resultado);
} ());
Faça uma exceção ao modificar os atributos somente leitura
O ECMAScript5 também apresenta a capacidade de definir propriedades específicas de um objeto para somente leitura ou tornar todo o objeto não modificado. No entanto, no modo não rigoroso, tentar modificar uma propriedade somente leitura só falhará em silêncio. É provável que isso aconteça com você durante o seu lidar com algumas APIs nativas do navegador. O modo rigoroso lançará explicitamente exceções neste caso, lembrando que a modificação dessa propriedade não é permitida.
A cópia do código é a seguinte:
var pessoa = {};
Object.DefineProperty (Pessoa, "Nome" {
gravável: falso,
Valor: "Nicholas"
});
// No modo não rito, o silêncio falha e uma exceção é lançada em modo rigoroso.
pessoa.name = "John";
No exemplo acima, o atributo de nome está definido como somente leitura. A execução da modificação do atributo de nome no modo não rígido não causará um erro, mas a modificação não será bem-sucedida. Mas o modo rigoroso lançará claramente exceções.
NOTA: É altamente recomendável que você habilite o modo rigoroso ao especificar usando qualquer atributo ECMAScript.
Como usá -lo?
É muito fácil ativar o modo rigoroso em navegadores modernos, só preciso aparecer o seguinte comando no código JavaScript
"Use rigoroso";
Embora o código acima pareça ser apenas uma string que não fornece uma determinada variável, na verdade significa que o mecanismo JavaScript muda para o modo rigoroso (os navegadores que não suportam o modo rigoroso ignorarão o código acima e não terão nenhum impacto na execução subsequente). Embora você possa aplicar esta instrução a uma função global ou uma, aqui devemos lembrá -lo de não ativar o modo rigoroso em um ambiente global.
A cópia do código é a seguinte:
// por favor, não use assim
"Use rigoroso";
função doSomething () {
// Esta parte do código será executada no modo rigoroso
}
função doSomethingelse () {
// Esta parte do código também será executada no modo rigoroso
}
Embora o código acima não pareça ser um grande problema. Mas quando você não é responsável por manter todo o código introduzido na página, o uso de modo rigoroso dessa maneira fará com que você tenha problemas causados por um código de terceiros não estar preparado para o modo rigoroso.
Portanto, é melhor usar instruções que permitam o modo rigoroso na função, por exemplo:
A cópia do código é a seguinte:
função doSomething () {
"Use rigoroso";
// O código nesta função será executado no modo rigoroso
}
função doSomethingelse () {
// O código nesta função não será executado no modo rigoroso
}
Se você deseja que o modo rigoroso seja ativado em mais de uma função, use a expressão de função inspirada imediatamente (IIFE):
A cópia do código é a seguinte:
(function () {
"Use rigoroso";
função doSomething () {
// Esta função é executada no modo rigoroso
}
função doSomethingelse () {
// Esta função também é executada no modo rigoroso
}
} ());
para concluir
Eu recomendo fortemente que você ative o modo rigoroso JavaScript a partir de agora, o que pode ajudá -lo a descobrir erros que você não notou em seu código. Não o habilite em um ambiente global, mas você pode usar o IIFE o máximo possível (execute expressões de função imediatamente) para aplicar padrões estritos a várias funções. No início, você encontrará mensagens de erro que nunca encontrou antes, o que é normal. Quando o modo rigoroso estiver ativado, teste -o nos navegadores suportados para descobrir novos problemas em potencial. Não apenas adicione uma linha "Use rigoroso" ao código e assuma que o código restante funcionará corretamente. Por fim, comece a escrever um código melhor no modo rigoroso.
Observação:
Aqui está um resumo das situações estritas de suporte de modo de cada navegador.
Você pode testar o suporte rigoroso do modo do navegador atual nesta página.
Vantagens do modo rigoroso:
Tornar o JavaScript mais forte
1. Isso não é mais encapsulado e, no modo normal, sempre foi um objeto.
2. Fun.Caller e Fun.Arguments não são propriedades deletáveis e não podem ser definidas ou recuperadas.
3. Argumentos.Caller também é um atributo que não pode ser excluído, nem pode ser definido ou recuperado.
Pavimentar o caminho para futuras versões do ecmascript
1. As seguintes palavras reservadas foram adicionadas: implementos, interface, deixar, pacote, privado, protegido, público, estático e rendimento.
2. A declaração do método deve ser colocada na frente do script ou método e não pode ser colocada no meio de declarações como se ou para.