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



nodejs pra (21)

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.

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?


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


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.


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.


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.


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


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.


A declaração "use strict"; instrui o navegador a usar o modo Strict, que é um conjunto de recursos reduzido e seguro do JavaScript.

Lista de recursos (não exaustivos)

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

  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 objeto sejam exclusivos ( var x = {x1: "1", x1: "2"} )

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

  6. Proibe a sintaxe 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 variáveis

  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 objeto 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 ]


É 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 função) 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.


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).


"use strict"; é o esforço do ECMA para tornar o JavaScript um pouco mais robusto. Ele traz em JS uma tentativa de torná-lo pelo menos um pouco "estrito" (outras linguagens implementam regras rígidas desde os anos 90). Na verdade, "força" os desenvolvedores de JavaScript a seguir algum tipo de práticas recomendadas de codificação. Ainda assim, o JavaScript é muito frágil. Não existem variáveis ​​tipadas, métodos tipados, etc. Recomendo fortemente que os desenvolvedores de JavaScript aprendam uma linguagem mais robusta, como Java ou ActionScript3, e implementem as mesmas práticas recomendadas em seu código JavaScript, ele funcionará melhor e será mais fácil depurar.


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


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) .


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:


"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 .


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 .


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.


"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.


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.


JavaScript

 var str = "My big string contain apples and oranges";
 var n = str.indexOf("apples"); 
 alert(n); //will alert 22, -1 if not found

jQuery

  <p>My big string contain apples and oranges</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found




javascript syntax jslint use-strict