javascript - sintaxis - JSLint esperaba ''==='' y en su lugar vio ''==''

sintaxis js online

Question

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

¿Eso realmente tiene sentido? Pude ver muchas instancias en las 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í.

Answer 1

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

Answer 2

IMO, usando ciegamente === , sin tratar de entender cómo funciona la conversión de tipo , no tiene mucho sentido.

El principal temor 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 eso:

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 operador typeof , que siempre es una cadena , con una cadena literal ...

O bien, cuando conoces las reglas de coerción de tipo, por ejemplo, comprueba si algo es null o algo undefined :

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
}

Answer 3

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 hace que '' /t/r/n'' == 0 sea ​​verdadero. Esto puede enmascarar errores de tipo.

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

Si solo te importa que un valor sea verdadero o falso , entonces usa la forma abreviada. En lugar de

(foo != 0)

sólo decir

(foo)

y en lugar de

(foo == 0)

decir

(!foo)

Los operadores === y !== son preferidos.

Answer 4

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

Es una buena práctica usar === 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 verdadero. Esto puede enmascarar errores de tipo. JSLint no puede determinar de manera confiable si == se está utilizando correctamente, por lo que es mejor no usar == y! = En absoluto y usar siempre los operadores más confiables === y !== en su lugar.

Reference

Answer 5

Si quieres probar la falsedad. JSLint no permite

if (foo == null)

pero permite

if (!foo)

Answer 6

Tenga en cuenta que JSLint impone la idea de una sola persona de lo que debe ser el 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 tipo no hace lo que usted cree que debería).

Answer 7

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

Entonces ("4" == 4) es verdadero, 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 el objetivo deliberado de hacer que su código JavaScript sea lo más estricto posible, con el objetivo de reducir errores desconocidos. Destaca este tipo de cosas para tratar de que codifiques de una manera que te obligue a respetar los tipos de datos.

Pero lo bueno de JSLint es que es solo una guía. Como dicen en el sitio, dañará tus sentimientos, incluso si eres un programador de JavaScript muy bueno. Pero no deberías sentirte obligado a seguir su consejo. Si ha leído lo que tiene que decir y lo comprende, pero está seguro de que su código no se va a romper, no hay obligación de que cambie nada.

Incluso puedes decirle a JSLint que ignore las categorías de cheques si no quieres que te bombardeen con advertencias de que no vas a hacer nada al respecto.

Answer 8

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

=== y! == Operadores.

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

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