javascript - solucion - variable=== indefinido vs. tipo de variable=== “indefinido”
undefined javascript error (7)
Me quedaría con el uso de typeof foo === "undefined" 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 variable undefined dentro de la función en la que reside el código jQuery, por lo que dentro de esa función undefined está a salvo de manipulación desde el exterior. También me imagino que alguien en algún lugar ha evaluado los dos enfoques diferentes y descubrió que foo === undefined es más rápido y, por lo tanto, decidió que es el camino a seguir. [ACTUALIZACIÓN: como se señaló en los comentarios, la comparación con undefined también es un poco más corta, lo que podría ser una consideración.] Sin embargo, la ganancia en situaciones prácticas será absolutamente insignificante: esta verificación nunca será, nunca, ningún tipo de cuello de botella, y lo que pierde es significativo: evaluar una propiedad de un objeto host para comparación puede generar un error, mientras que una comprobación de tipo nunca lo hará.
Por ejemplo, lo siguiente se usa en IE para analizar XML:
var x = new ActiveXObject("Microsoft.XMLDOM");
Para comprobar si tiene un método loadXML forma segura:
typeof x.loadXML === "undefined"; // Returns false
Por otra parte:
x.loadXML === undefined; // Throws an error
ACTUALIZAR
Otra ventaja del tipo de comprobación que olvidé mencionar es que también funciona con variables no declaradas, que la verificación foo === undefined no hace, y de hecho arroja un error de ReferenceError . Gracias a @LinusKleen por recordármelo. Por ejemplo:
typeof someUndeclaredVariable; // "undefined"
someUndeclaredVariable === undefined; // throws a ReferenceError
Línea inferior: utilice siempre el tipo de verificación.
Las pautas de estilo de jQuery Core sugieren dos formas diferentes de verificar si una variable está definida.
- Variables globales: tipo de
typeof variable === "undefined" - Variables locales:
variable === undefined - Propiedades:
object.prop === undefined
¿Por qué jQuery utiliza un enfoque para variables globales y otro para locales y propiedades?
Otra razón más para usar el tipo de variante: undefined se puede redefinir.
undefined = "foo";
var variable = "foo";
if (variable === undefined)
console.log("eh, what?!");
El resultado de la typeof variable no puede.
Actualización : tenga en cuenta que este no es el caso en ES5.
Para las variables locales, la verificación con localVar === undefined funcionará porque deben haberse definido en algún lugar dentro del alcance local o no se considerarán locales.
Para las variables que no son locales y no están definidas en ninguna parte, la verificación someVar === undefined emitirá una excepción: Uncught ReferenceError: j no está definido
Aquí hay un código que aclarará lo que estoy diciendo arriba. Por favor, preste atención a los comentarios en línea para mayor claridad .
function f (x) {
if (x === undefined) console.log(''x is undefined [x === undefined].'');
else console.log(''x is not undefined [x === undefined.]'');
if (typeof(x) === ''undefined'') console.log(''x is undefined [typeof(x) === /'undefined/'].'');
else console.log(''x is not undefined [typeof(x) === /'undefined/'].'');
// This will throw exception because what the hell is j? It is nowhere to be found.
try
{
if (j === undefined) console.log(''j is undefined [j === undefined].'');
else console.log(''j is not undefined [j === undefined].'');
}
catch(e){console.log(''Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.'');}
// However this will not throw exception
if (typeof j === ''undefined'') console.log(''j is undefined (typeof(x) === /'undefined/'). We can use this check even though j is nowhere to be found in our source code and it will not throw.'');
else console.log(''j is not undefined [typeof(x) === /'undefined/'].'');
};
Si llamamos al código anterior como este:
f();
La salida sería esta:
x is undefined [x === undefined].
x is undefined [typeof(x) === ''undefined''].
Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.
j is undefined (typeof(x) === ''undefined''). We can use this check even though j is nowhere to be found in our source code and it will not throw.
Si llamamos al código anterior como estos (con cualquier valor en realidad):
f(null);
f(1);
La salida será:
x is not undefined [x === undefined].
x is not undefined [typeof(x) === ''undefined''].
Error!!! Cannot use [j === undefined] because j is nowhere to be found in our source code.
j is undefined (typeof(x) === ''undefined''). We can use this check even though j is nowhere to be found in our source code and it will not throw.
Cuando realiza la comprobación de este modo: typeof x === ''undefined'' , básicamente está preguntando esto: compruebe si la variable x existe (se ha definido) en algún lugar del código fuente. (más o menos). Si conoces C # o Java, este tipo de verificación nunca se realiza porque si no existe, no se compilará.
Para las variables no declaradas, typeof foo devolverá la cadena literal "undefined" , mientras que la verificación de identidad foo === undefined activaría el error "foo no está definido" .
Para las variables locales (que sabe que están declaradas en algún lugar), no se producirá tal error, por lo tanto, la verificación de identidad.
Porque no siempre se declara undefined , pero jQuery declara undefined en su función principal. Por lo tanto, usan el valor seguro undefined internamente, pero en el exterior, usan el estilo de typeof para estar seguros.
Quien esté interesado en la ganancia de rendimiento de la variable === undefined , puede echar un vistazo aquí, pero parece ser solo una optimización de Chrome.
typeof a === ''undefined'' es más rápido que a === ''undefined'' por aproximadamente 2 veces en el nodo v6.9.1.