¿Está bien para usar la coerción de tipo cuando se busca indefinido / nulo?

¿Es aceptable usar coerción de tipo (== en lugar de ===) para verificar si no está definido / nulo?

¿Cuáles son los inconvenientes? ¿Hay una mejor manera de verificar si no está definido / nulo?

Aclaración: estoy buscando una statement que verifique tanto indefinida como nula.

test(null); test(undefined); function test(myVar) { if (myVar != undefined) { alert('never gets called') } } 

Voy a tratar de abordar esta cuestión de la manera más objetiva posible, pero se trata de algunas "mejores prácticas" de opinión que pueden llevar a las personas a olvidar que hay más de una forma de hacer las cosas.

¿Es aceptable usar coerción de tipo ( == lugar de === ) para verificar si undefined / null ?

Es aceptable escribir el código como mejor le parezca, independientemente de cualquier persona que le diga lo contrario. Incluyéndome a mí.

Eso no es realmente útil aquí, así que permítanme ampliar un poco, y les dejaré decidir cómo se sienten al respecto.

El código es una herramienta que se puede usar para resolver problemas, y == es una herramienta dentro del código JavaScript para resolver un problema específico . Tiene un algorithm bien definido que sigue para verificar un tipo de igualdad entre dos parameters.

=== , por otro lado, es una herramienta diferente que resuelve un problema diferente y específico . También tiene un algorithm bien definido que sigue para verificar un tipo de igualdad entre dos parameters.

Si una herramienta u otra es apropiada para su caso de uso, entonces no debe dudar en usar la herramienta.

Si necesitas un martillo, usa un martillo.

Pero si todo lo que tienes es un martillo, entonces todo parece un clavo , y este es el problema principal con == . Los desarrolladores que vienen de otros idiomas a menudo no son conscientes de cómo funciona == y lo usan cuando === sería apropiado.

De hecho, la mayoría de los casos de uso son tales que === debería preferirse a más de == , pero como ha hecho en su pregunta: eso no es cierto en este caso.

¿Cuáles son los inconvenientes?

Si relajas tus estándares para === y permites que los desarrolladores usen == es muy posible que te muerdan por el uso incorrecto de == , que es por lo que apegarse religiosamente a === puede ser aceptable para algunos, y parecer tonto para otros.

 if (val === null || val === undefined) {... 

no es particularmente difícil de escribir, y es muy explícito sobre la intención.

Alternativamente,

 if (val == null) {... 

es mucho más conciso, y no es difícil de entender tampoco.

¿Hay una mejor manera de verificar si undefined / null ?

"mejor" es subjetivo, pero voy a decir "no" de todos modos porque no conozco ninguno que mejore la situación de manera significativa.

En este punto, también notaré que hay otras comprobaciones que podrían realizarse en lugar de null / undefined . Los controles Truthy / falsey son comunes, pero son otra herramienta utilizada para resolver otro problema específico :

 if (!val) {... 

es mucho más conciso que cualquiera de las opciones anteriores, sin embargo, viene con el equipaje de tragar otros valores falsey.


Notas adicionales sobre la aplicación a través de la pelusa:

Si sigue la rigurosidad de JSLint de Crockford , == nunca se tolera, en el entendido de que una herramienta que es "a veces útil" pero "más que peligrosa" no justifica el riesgo.

ESLint , por otro lado, permite una interpretación más liberal de la regla al proporcionar una opción para permitir null como una exception específica.

== undefined y == null son ambos equivalentes a verificar si el valor es indefinido o nulo, y nada más.

En cuanto a "aceptable", depende de quién esté mirando el código y si su linter está configurado para ignorar este caso especial.

Puedo asegurarte que algunos minificadores ya hacen esta optimization por ti.

La forma ideal de probar indefinido es usar typeof . Tenga en count que solo necesita probarlos por separado si le importa una diferencia entre undefined y null :

 test(null); test(undefined); function test(myVar) { if (typeof myVar === "undefined") { // its undefined } if (myVar === null) { // its null } } 

Si no te importa si es undefined / null , solo hazlo:

 test(null); test(undefined); function test(myVar) { if (!myVar) { // its undefined or null, dunno which, don't care! } }