JSLint esperado '===' e em vez disso vi '=='

Recentemente, eu estava executando parte do meu código por meio de JSLint quando encontrei esse erro. O que eu acho engraçado sobre esse erro, porém, é que ele assume automaticamente que todos == deveriam ser ===.

Isso realmente faz algum sentido? Eu pude ver muitos casos em que você não gostaria de comparar o tipo e estou preocupado que isso possa realmente causar problemas.

A palavra "Esperado" implicaria que isso deve ser feito TODAS as vezes ... Isso é o que não faz sentido para mim.

IMO, usar cegamente ===, sem tentar entender como funciona a conversão de tipo , não faz muito sentido.

O principal medo sobre o operador Equals ==é que as regras de comparação, dependendo dos tipos comparados, podem tornar o operador não transitivo, por exemplo, se:

A == B AND
B == C

Realmente não garante que:

A == C

Por exemplo:

'0' == 0;   // true
 0  == '';  // true
'0' == '';  // false

O operador Strict Equals ===não é realmente necessário quando você compara valores do mesmo tipo, o exemplo mais comum:

if (typeof foo == "function") {
  //..
}

Comparamos o resultado do typeofoperador, que é sempre uma string , com um literal de string ...

Ou quando você conhece as regras de coerção de tipo, por exemplo, verifique se algo é nullou undefinedalgo:

if (foo == null) {
  // foo is null or undefined
}

// Vs. the following non-sense version:

if (foo === null || typeof foo === "undefined") {
  // foo is null or undefined
}

JSLint é inerentemente mais defensivo do que a sintaxe Javascript permite.

Da documentação JSLint:

Os operadores ==e !=fazem coerção de tipo antes de comparar. Isso é ruim porque faz ' \t\r\n' == 0com que seja verdade. Isso pode mascarar erros de tipo.

Ao comparar com qualquer um dos seguintes valores, use os operadores ===ou !==(que não fazem coerção de tipo):0 '' undefined null false true

Se você só se preocupam que um valor é truthy ou Falsas , então use o pequeno formulário. Ao invés de

(foo != 0)

apenas diga

(foo)

e em vez de

(foo == 0)

dizer

(!foo)

Os operadores ===e !==são os preferidos.

Lembre-se de que o JSLint impõe a ideia de uma pessoa do que um bom JavaScript deve ser. Você ainda precisa usar o bom senso ao implementar as mudanças que ele sugere.

Em geral, comparar tipo e valor tornará seu código mais seguro (você não terá o comportamento inesperado quando a conversão de tipo não fizer o que você acha que deveria).

Triplo igual é diferente de duplo igual porque, além de verificar se os dois lados têm o mesmo valor, triplo igual também verifica se eles são do mesmo tipo de dados.

Então, ("4" == 4)é verdade, mas ("4" === 4)é falso.

Triplo-igual também é executado um pouco mais rápido, porque JavaScript não precisa perder tempo fazendo nenhuma conversão de tipo antes de fornecer a resposta.

JSLint visa deliberadamente tornar seu código JavaScript o mais estrito possível, com o objetivo de reduzir bugs obscuros. Ele destaca esse tipo de coisa para tentar fazer com que você codifique de uma forma que o force a respeitar os tipos de dados.

Mas o bom do JSLint é que ele é apenas um guia. Como dizem no site, vai magoar seus sentimentos, mesmo se você for um programador de JavaScript muito bom. Mas você não deve se sentir obrigado a seguir seus conselhos. Se você leu o que ele tem a dizer e o entende, mas tem certeza de que seu código não vai quebrar, então não há compulsão para mudar nada.

Você pode até mesmo dizer ao JSLint para ignorar categorias de verificações se não quiser ser bombardeado com avisos de que nada fará a respeito.

Uma citação de http://javascript.crockford.com/code.html :

=== e! == Operadores.

Quase sempre é melhor usar os operadores === e! ==. Os operadores == e! = Fazem coerção de tipo. Em particular, não use == para comparar com valores falsos.

JSLint é muito rígido, seu 'webjslint.js' nem passa pela sua própria validação.

Se você quiser testar a falsidade. JSLint não permite

if (foo == null)

mas permite

if (!foo)

Para ajudar a explicar esta questão e também explicar por que o NetBeans (de) 7.3 começou a mostrar este aviso, este é um extrato da resposta no rastreador de bug do NetBeans quando alguém relatou isso como um bug:

É uma boa prática usar === em vez de == em JavaScript.

Os operadores == e! = Fazem coerção de tipo antes de comparar. Isso é ruim porque faz com que '\ t \ r \ n' == 0 seja verdadeiro. Isso pode mascarar erros de tipo. O JSLint não pode determinar com segurança se == está sendo usado corretamente, então é melhor não usar == e! = De forma alguma e sempre usar os operadores === e! == mais confiáveis.

Referência

Bem, isso não pode realmente causar problemas, é apenas dar conselhos. É pegar ou largar. Dito isso, não tenho certeza de quão inteligente é. Pode muito bem haver contextos em que isso não apresente como um problema.