JSLint esperaba '===' y en su lugar vio '=='

Recientemente, estaba ejecutando parte de mi código a través de JSLint cuando se me ocurrió este error. Sin embargo, lo que creo que es gracioso acerca de este error es que automáticamente asume que todos == deberían ser ===.

¿Eso realmente tiene algún sentido? Pude ver muchos casos en los que no querría comparar el tipo y me preocupa que esto realmente pueda causar problemas.

La palabra "esperado" implicaría que esto debería hacerse CADA vez ..... Eso es lo que no tiene sentido para mí.

En mi opinión, usar ciegamente ===, sin tratar de entender cómo funciona la conversión de tipos , no tiene mucho sentido.

El temor principal sobre el operador Equals ==es que las reglas de comparación que dependen de los tipos comparados pueden hacer que el operador no sea transitivo, por ejemplo, si:

A == B AND
B == C

Realmente no garantiza que:

A == C

Por ejemplo:

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

El operador Strict Equals ===no es realmente necesario cuando compara valores del mismo tipo, el ejemplo más común:

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

Comparamos el resultado del typeofoperador, que siempre es una cadena , con un literal de cadena ...

O cuando conozca las reglas de coerción de tipos, por ejemplo, verifique si algo es nullo 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 es inherentemente más defensivo de lo que permite la sintaxis de Javascript.

De la documentación de JSLint:

Los operadores ==y !=escriben coerción antes de comparar. Esto es malo porque causa ' \t\r\n' == 0que sea verdad. Esto puede enmascarar errores de tipo.

Al comparar con cualquiera de los siguientes valores, use los operadores ===o !==(que no utilizan coerción de tipos):0 '' undefined null false true

Si solo le importa que un valor sea verdadero o falso , utilice la forma abreviada. En vez de

(foo != 0)

sólo decir

(foo)

y en lugar de

(foo == 0)

decir

(!foo)

Se prefieren los operadores ===y !==.

Tenga en cuenta que JSLint refuerza la idea de una persona de lo que debería ser un buen JavaScript. Aún debe usar el sentido común al implementar los cambios que sugiere.

En general, comparar el tipo y el valor hará que su código sea más seguro (no se encontrará con el comportamiento inesperado cuando la conversión de tipos no haga lo que usted cree que debería hacer).

Triple-igual es diferente a doble-igual porque además de verificar si los dos lados tienen el mismo valor, triple-igual también verifica que sean del mismo tipo de datos.

Entonces ("4" == 4)es cierto, mientras que ("4" === 4)es falso.

Triple-equal también se ejecuta un poco más rápido, porque JavaScript no tiene que perder tiempo haciendo conversiones de tipo antes de darle la respuesta.

JSLint tiene como objetivo deliberadamente hacer que su código JavaScript sea lo más estricto posible, con el objetivo de reducir errores oscuros. Destaca este tipo de cosas para intentar que codifique de una manera que lo obligue a respetar los tipos de datos.

Pero lo bueno de JSLint es que es solo una guía. Como dicen en el sitio, herirá tus sentimientos, incluso si eres un muy buen programador de JavaScript. Pero no debe sentirse obligado a seguir sus consejos. Si ha leído lo que tiene que decir y lo entiende, pero está seguro de que su código no se romperá, entonces no hay obligación de cambiar nada.

Incluso puede decirle a JSLint que ignore las categorías de comprobaciones si no quiere ser bombardeado con advertencias sobre las que no va a hacer nada.

Una cita de http://javascript.crockford.com/code.html :

=== y! == Operadores.

Casi siempre es mejor utilizar los operadores === y! ==. Los operadores == y! = Escriben coerción. En particular, no use == para comparar con valores falsos.

JSLint es muy estricto, su 'webjslint.js' ni siquiera pasa su propia validación.

Si quieres probar la falsedad. JSLint no permite

if (foo == null)

pero permite

if (!foo)

Para ayudar a explicar esta pregunta y también explicar por qué NetBeans (de) 7.3 ha comenzado a mostrar esta advertencia, este es un extracto de la respuesta en el rastreador de errores de NetBeans cuando alguien informó esto como un error:

Es una buena práctica utilizar === en lugar de == en JavaScript.

Los operadores == y! = Escriben coerción antes de comparar. Esto es malo porque hace que '\ t \ r \ n' == 0 sea cierto. Esto puede enmascarar errores de tipo. JSLint no puede determinar de manera confiable si == se está usando correctamente, por lo que es mejor no usar == y! = En absoluto y siempre usar los operadores === y! == más confiables en su lugar.

Referencia

Bueno, realmente no puede causar problemas, solo te está dando un consejo. Tómelo o déjelo. Dicho esto, no estoy seguro de lo inteligente que es. Bien puede haber contextos en los que no lo presente como un problema.