Verificación de JavaScript si la variable existe (está definida / inicializada)

¿Qué método para verificar si una variable se ha inicializado es mejor / correcto? (Suponiendo que la variable pueda contener algo (cadena, int, objeto, función, etc.))

if (elem) { // or !elem 

o

 if (typeof(elem) !== 'undefined') { 

o

 if (elem != null) { 

Quieres el operador de typeof . Específicamente:

 if (typeof variable !== 'undefined') { // the variable is defined } 

El operador typeof comprobará si la variable no está definida.

 if (typeof variable === 'undefined') { // variable is undefined } 

El operador typeof , a diferencia de los otros operadores, no lanza una excepción ReferenceError cuando se usa con una variable no declarada.

Sin embargo, tenga en cuenta que typeof null devolverá "object" . Debemos tener cuidado para evitar el error de inicializar una variable a null . Para estar seguro, esto es lo que podríamos usar en su lugar:

 if (typeof variable === 'undefined' || variable === null) { // variable is undefined or null } 

Para obtener más información sobre el uso de la comparación estricta === lugar de simple igualdad == , ver:
¿Qué operador igual (== vs ===) se debe usar en las comparaciones de JavaScript?

En JavaScript, se puede definir una variable, pero mantener el valor undefined , por lo que la respuesta más común no es técnicamente correcta, y en su lugar realiza lo siguiente:

 if (typeof v === "undefined") { // no variable "v" is defined in the current scope // *or* some variable v exists and has been assigned the value undefined } else { // some variable (global or local) "v" is defined in the current scope // *and* it contains a value other than undefined } 

Eso puede ser suficiente para sus propósitos. La siguiente prueba tiene una semántica más simple, lo que hace que sea más fácil describir con precisión el comportamiento de su código y entenderlo usted mismo (si le importan esas cosas):

 if ("v" in window) { // global variable v is defined } else { // global variable v is not defined } 

Esto, por supuesto, asume que se está ejecutando en un navegador (donde la window es un nombre para el objeto global). Pero si estás jugando con globos como este, probablemente estés en un navegador. Subjetivamente, el uso de 'name' in window es estilísticamente consistente con el uso de window.name para referirse a globales. Acceder a las variables globales como propiedades de la window lugar de como variables le permite minimizar el número de variables no declaradas a las que hace referencia en su código (para el beneficio de la pelusa) y evita la posibilidad de que su sombra global sea ensombrecida por una variable local. Además, si los globals hacen que tu piel se arrastre, es posible que te sientas más cómodo si los tocas solo con este bastón relativamente largo.

En la mayoría de los casos, usarías:

 elem != null 

A diferencia de un simple if (elem) , permite 0 , false , NaN y '' , pero rechaza null o undefined , por lo que es una buena prueba general para la presencia de un argumento o propiedad de un objeto.


Los otros controles tampoco son incorrectos, solo tienen diferentes usos:

  • if (elem) : se puede usar si se garantiza que elem es un objeto, o si false , 0 , etc. se consideran valores “predeterminados” (por lo tanto, equivalentes a undefined o null ).

  • typeof elem == 'undefined' se puede usar en casos donde un null especificado tiene un significado distinto para una variable o propiedad no inicializada.

    • Esta es la única verificación que no lanzará un error si elem no está declarado (es decir, no hay una sentencia var , no es una propiedad de la window , o no es un argumento de la función). Esto es, en mi opinión, bastante peligroso ya que permite que los errores tipográficos pasen inadvertidos. Para evitar esto, mira el siguiente método.

También es útil una comparación estricta contra undefined :

 if (elem === undefined) ... 

Sin embargo, dado que el valor global undefined puede anularse con otro valor, es mejor declarar la variable undefined en el ámbito actual antes de usarlo:

 var undefined; // really undefined if (elem === undefined) ... 

O:

 (function (undefined) { if (elem === undefined) ... })(); 

Una ventaja secundaria de este método es que los minificadores JS pueden reducir la variable undefined a un único carácter, ahorrándole algunos bytes cada vez.

En muchos casos, usando:

 if (elem) { // or !elem 

hará el trabajo por usted! … esto comprobará estos casos a continuación:

  1. indefinido : si el valor no está definido y no está undefined
  2. null : si es nulo, por ejemplo, si un elemento DOM no existe …
  3. cadena vacía : ''
  4. 0 : número cero
  5. NaN : no es un número
  6. falso

Por lo tanto, cubrirá todo tipo de casos, pero siempre hay casos extraños que también nos gustaría cubrir, por ejemplo, una cadena con espacios como este, esto se definirá en JavaScript ya que tiene espacios. Dentro de la cadena … por ejemplo, en este caso agrega una marca más usando trim (), como:

 if(elem) { if(typeof elem === 'string' && elem.trim()) { /// 

Además, estas comprobaciones son solo para valores , ya que los objetos y las matrices funcionan de forma diferente en Javascript, la matriz vacía [] y el objeto vacío {} siempre son verdaderas .

Creé la imagen a continuación para mostrar un breve resumen de la respuesta:

indefinido, nulo, etc.

Cómo verificar si existe una variable

Esta es una solución bastante a prueba de balas para probar si existe una variable y se ha inicializado:

 var setOrNot = typeof variable !== typeof undefined; 

Se usa más comúnmente en combinación con un operador ternario para establecer un valor predeterminado en caso de que una cierta variable no se haya inicializado:

 var dark = typeof darkColor !== typeof undefined ? darkColor : "black"; 

Problemas con la encapsulación

Desafortunadamente, no puedes simplemente encapsular tu cheque en una función.

Puede pensar en hacer algo como esto:

 function isset(variable) { return typeof variable !== typeof undefined; } 

Sin embargo, esto producirá un error de referencia si está llamando, por ejemplo. isset(foo) y variable foo no se ha definido, porque no se puede pasar una variable no existente a una función:

UnEdge ReferenceError: foo no está definido


Comprobando si los parámetros de la función no están definidos

Si bien nuestra función isset no se puede utilizar para probar si existe o no una variable (por las razones explicadas anteriormente), sí nos permite comprobar si los parámetros de una función no están definidos:

 var a = '5'; var test = function(x, y) { console.log(isset(x)); console.log(isset(y)); }; test(a); // OUTPUT : // ------------ // TRUE // FALSE 

Aunque no se transfiere ningún valor para y a la test función, nuestra función isset funciona perfectamente en este contexto, porque y se conoce en la test función como un valor undefined .

Comprueba si un objeto tiene hasOwnProperty()

Una alternativa a la gran cantidad de respuestas hasOwnProperty() es el uso de hasOwnProperty() que, por supuesto, comprueba si un objeto (prácticamente todo en JS) tiene una propiedad, es decir, una variable (entre otras cosas).

El método hasOwnProperty() devuelve un valor booleano que indica si el objeto tiene la propiedad especificada como propiedad propia (no heredada).

Cada objeto que desciende de Object hereda el método hasOwnProperty() . Este método se puede usar para determinar si un objeto tiene la propiedad especificada como propiedad directa de ese objeto; a diferencia del operador en , este método no comprueba la cadena de prototipos del objeto.

 // Globally established (therefore) properties of window var foo = "whatever", // string bar = false, // bool baz; // undefined // window.qux does not exist console.log( [ window.hasOwnProperty( "foo" ), // true window.hasOwnProperty( "bar" ), // true window.hasOwnProperty( "baz" ), // true window.hasOwnProperty( "qux" ), // false { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true ] ); 

Hay otra forma de mano corta para verificar esto, cuando realiza asignaciones simples y comprobaciones relacionadas. Simplemente use el operador condicional (ternario).

 var values = typeof variable !== 'undefined' ? variable : ''; 

También esto será útil cuando intente declarar la variable Global con la asignación de instancia de la variable de referencia.

Si desea verificar la variable no debe estar undefined o null . A continuación, realice la comprobación siguiente.

Cuando se declara la variable, y si desea verificar el valor, esto es incluso Simple: y realizaría controles undefined y null juntos.

 var values = variable ? variable : ''; 

undefined, boolean, string, number, function

 if (typeof foo! == 'undefined') { 

 } 

Objeto, matriz

 if( foo instanceof Array ) { } 

Depende si te preocupa que la variable se haya definido o si quieres que tenga un valor significativo.

Verificando si el tipo está indefinido verificará si la variable ya se ha definido.

=== null o !== null solo verificará si el valor de la variable es exactamente null .

== null o != null verificará si el valor es undefined o null .

if(value) comprobará si la variable undefined está undefined , null , 0 o una cadena vacía.

La respuesta más alta es correcta, use typeof.

Sin embargo, lo que quería señalar es que en JavaScript undefined es mutable (por alguna razón impía). ¡Simplemente hacer un chequeo para varName !== undefined tiene el potencial de no siempre regresar como esperabas, porque otras libs podrían haber cambiado undefined. Algunas respuestas (@ skalee’s, por ejemplo) parecen preferir no usar typeof , y eso podría causar problemas.

La “vieja” forma de manejar esto se declaraba indefinida como una var para compensar cualquier muting / over-riding potencial de undefined . Sin embargo, la mejor manera es usar typeof porque ignorará cualquier anulación de undefined de otro código. Especialmente si está escribiendo código para usar en la naturaleza, ¿quién sabe qué más podría estar ejecutando en la página …

 if (typeof console != "undefined") { ... } 

O mejor

 if ((typeof console == "object") && (typeof console.profile == "function")) { console.profile(f.constructor); } 

Funciona en todos los navegadores

Para contribuir al debate, si sé que la variable debe ser una cadena o un objeto, siempre prefiero if (!variable) , para verificar si es falso. Esto puede llevar a un código más limpio para que, por ejemplo:

 if (typeof data !== "undefined" && typeof data.url === "undefined") { var message = 'Error receiving response'; if (typeof data.error !== "undefined") { message = data.error; } else if (typeof data.message !== "undefined") { message = data.message; } alert(message); } 

Es difícil distinguir entre indefinido y nulo. Nulo es un valor que puede asignar a una variable cuando desea indicar que la variable no tiene un valor particular. Indefinido es un valor especial que será el valor predeterminado de las variables no asignadas.

var _undefined; var _null = null; alert(_undefined); alert(_null); alert(_undefined == _null); alert(_undefined === _null);
var _undefined; var _null = null; alert(_undefined); alert(_null); alert(_undefined == _null); alert(_undefined === _null); 

Null es un valor en JavaScript y typeof null devuelve "object"

Por lo tanto, la respuesta aceptada no funcionará si pasa valores nulos. Si pasa valores nulos, debe agregar una verificación adicional para los valores nulos:

 if ((typeof variable !== "undefined") && (variable !== null)) { // the variable is defined and not null } 

Estas respuestas (aparte de la solución de Fred Gandt) son todas incorrectas o incompletas.

Supongamos que necesito mi variableName; para llevar un valor undefined , y por lo tanto se ha declarado de una manera como var variableName; lo que significa que ya está inicializado ; – ¿Cómo verifico si ya está declarado?

O aún mejor, ¿cómo puedo comprobar inmediatamente si existe “Book1.chapter22.paragraph37” con una sola llamada, pero no se genera un error de referencia?

Lo hacemos utilizando el operador de JasvaScript más poderoso, el operador de entrada .:

 "[variable||property]" in [context||root] >> true||false 

En tiempos de popularidad pico AJAX he escrito un método (más tarde llamado) isNS () que es capaz de determinar si el espacio de nombres existe, incluidas pruebas profundas para nombres de propiedades como “Book1.chapter22.paragraph37” y mucho más.

Pero como ha sido publicado previamente y debido a su gran importancia, merece ser publicado en un hilo separado, no lo publicaré aquí, sino que proporcionaré palabras clave ( javascript + isNS ) que lo ayudarán a localizar el código fuente, respaldado con todos los explicaciones necesarias.

La comprobación más robusta “está definida” es con typeof

 if (typeof elem === 'undefined') 

Si solo está buscando una variable definida para asignar un valor predeterminado, para un trazador de líneas de fácil lectura a menudo puede hacer esto:

 elem = elem || defaultElem; 

A menudo está bien usarlo, mira: forma idiomática de establecer el valor predeterminado en javascript

También existe este trazador de líneas utilizando la palabra clave typeof :

 elem = (typeof elem === 'undefined') ? defaultElem : elem; 

puedes usar el operador typeof .

Por ejemplo,

 var dataSet; alert("Variable dataSet is : " + typeof dataSet); 

El fragmento de código anterior devolverá el resultado como

variable dataSet es: undefined.

En la situación particular descrita en la pregunta,

 typeof window.console === "undefined" 

es idéntico a

 window.console === undefined 

Prefiero este último ya que es más corto.

Tenga en cuenta que buscamos la console solo en el ámbito global (que es un objeto de window en todos los navegadores). En esta situación particular, es deseable. No queremos console definida en otro lugar.

@BrianKelley en su gran respuesta explica los detalles técnicos. Solo agregué la conclusión faltante y digerí en algo más fácil de leer.

Mi preferencia es typeof(elem) != 'undefined' && elem != null .

Como lo elija, considere poner el cheque en una función como tal

 function existy (x) { return typeof (x) != 'undefined' && x != null; } 

Si no sabe que la variable está declarada, continúe con typeof (x) != 'undefined' && x != null;

Donde sabes que la variable está declarada pero puede no existir, podrías usar

 existy(elem) && doSomething(elem); 

La variable que está revisando puede ser una propiedad anidada a veces. Puedes usar prop || {} para ir a la línea que verifica la existencia de la propiedad en cuestión:

 var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4; 

Después de cada propiedad use (… ‘|| {}’). NextProp para que una propiedad faltante no arroje un error.

O puede usar existy como existy(o) && existy(op) && existy(opq) && doSomething(opq)

Si quieres que el bloque definido haga algo, utiliza esto

 if (typeof variable !== 'undefined') { // the variable is defined } 

Si desea que un bloque no definido haga algo o asigne o defina la variable, utilice este

 if (typeof variable === 'undefined') { // the variable is undefined } 

Utilizo dos formas diferentes dependiendo del objeto.

 if( !variable ){ // variable is either // 1. ''; // 2. 0; // 3. undefined; // 4. null; // 5. false; } 

A veces no quiero evaluar una cadena vacía como Falsey, entonces uso esta funda

 function invalid( item ){ return (item === undefined || item === null); } if( invalid( variable )){ // only here if null or undefined; } 

Si necesita lo contrario, entonces, en el primer caso, la variable se convierte en variable, y en la función no válida === convertirse en! = Y los nombres de las funciones cambian a no válido.

Depende de la situación. Si está buscando algo que puede o no haber sido definido globalmente fuera de su código (como jQuery quizás), usted quiere:

 if (typeof(jQuery) != "undefined") 

(No hay necesidad de igualdad estricta allí, typeof siempre devuelve una cadena.) Pero si tiene argumentos para una función que puede o no haber sido aprobada, siempre estarán definidos, pero nulos si se omiten.

 function sayHello(name) { if (name) return "Hello, " + name; else return "Hello unknown person"; } sayHello(); // => "Hello unknown person" 

Un poco más funcional y fácil de usar:

 function exist(obj) { return (typeof obj !== 'undefined'); } 

La función devolverá verdadero si existe, de lo contrario será falso si no existe.

¿Qué tal un simple:

 if(!!variable){ //the variable is defined } 

Tenga en cuenta que cuando comprueba! == o! = Contra “indefinido” no funcionará

Probado en Firfox Quantom 60.0.1

utilice la prueba como esta en su lugar para evitar conflictos

 if(!(typeof varibl['fl'] === 'undefined')) { console.log(varibl['fl']); console.log("Variable is Defined"); }else{ console.log(varibl['fl']); console.log("Variable is Un-Defined"); } 

Para verificar si una variable ha sido declarada / configurada, hice este sucio truco.

No he encontrado una forma de extraer el código de una función, incluso con eval .

 "use strict"; // var someVar; var declared; try { someVar; declared = true; } catch(e) { declared = false; } if (declared) { console.log("someVar is declared; now has the value: " + someVar); } else { console.log("someVar is not declared"); } 

Inseguro de si esto ayudaría, necesitaba verificar si se estaba recogiendo un Var definido en la página antes de ejecutar los scripts relacionados, y lo siguiente funcionó bien para mí.

 if (window.myvar) { // run scripts here } 

Es un poco simple pero está bien para uno o más.

No puedo ver esto en las respuestas anteriores, así que lo sugeriré aquí, supongo.

 function isDefined(x) { return !!x } if( isDefined(x) ) { //The variable is defined } 

! x devolverá true iff x es nulo o indefinido , por lo que !! x solo devolverá true iff x no está indefinido ni nulo.

Me doy cuenta de que esto también explica el caso nulo, pero aquí hay una advertencia justa sobre eso.