variable === indefinida frente a tipo de variable === "indefinida"
Las pautas de estilo principales de jQuery sugieren dos formas diferentes de verificar si una variable está definida.
- Variables globales:
typeof variable === "undefined" - Variables locales:
variable === undefined - Propiedades:
object.prop === undefined
¿Por qué jQuery usa un enfoque para variables globales y otro para locales y propiedades?
Para variables no declaradas, typeof foodevolverá la cadena "undefined", mientras que la verificación de identidad foo === undefinedprovocará el error "foo no está definido" .
Para las variables locales (que usted sabe que están declaradas en alguna parte), no se produciría tal error, de ahí la verificación de identidad.
Yo seguiría usándolo typeof foo === "undefined"en todas partes. Eso nunca puede salir mal.
Me imagino que la razón por la que jQuery recomienda los dos métodos diferentes es que definen su propia undefinedvariable dentro de la función en la que reside el código jQuery, por lo que dentro de esa función undefinedestá a salvo de manipulaciones externas. También me imagino que alguien en algún lugar haya evaluado los dos enfoques diferentes y haya descubierto que foo === undefinedes más rápido y, por lo tanto, haya decidido que es el camino a seguir. [ACTUALIZACIÓN: como se indica en los comentarios, la comparación con undefinedtambién es un poco más corta, lo que podría ser una consideración.] Sin embargo, la ganancia en situaciones prácticas será completamente insignificante: esta verificación nunca, nunca será ningún tipo de cuello de botella, y lo que lo que pierde es significativo: evaluar una propiedad de un objeto host para compararla puede arrojar un error, mientras que una typeofverificación nunca lo hará.
Por ejemplo, lo siguiente se utiliza en IE para analizar XML:
var x = new ActiveXObject("Microsoft.XMLDOM");
Para comprobar si tiene un loadXMLmétodo de forma segura:
typeof x.loadXML === "undefined"; // Returns false
Por otro lado:
x.loadXML === undefined; // Throws an error
ACTUALIZAR
Otra ventaja de la typeofverificación que olvidé mencionar es que también funciona con variables no declaradas, cosa que la foo === undefinedverificación no hace, y de hecho arroja un archivo ReferenceError. Gracias a @LinusKleen por recordármelo. Por ejemplo:
typeof someUndeclaredVariable; // "undefined"
someUndeclaredVariable === undefined; // throws a ReferenceError
En pocas palabras: utilice siempre el typeofcheque.
