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

if (elem) { // or !elem

o

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

o

if (elem != null) {

Tú quieres el typeofoperador . Específicamente:

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

El typeofoperador verificará si la variable está realmente indefinida.

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

El typeofoperador, 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 nullvolverá "object". Tenemos que tener cuidado para evitar el error de inicializar una variable null. Para estar seguros, 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 en ===lugar de la igualdad simple ==, consulte:
¿Qué operador igual (== vs ===) debe usarse en las comparaciones de JavaScript?

En muchos casos, usando:

if (elem) { // or !elem

¡hará el trabajo por usted! ... esto verificará los siguientes casos:

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

Por lo tanto, cubrirá todos los 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 un cheque 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 manera diferente en Javascript, la matriz []vacía y el objeto vacío {}siempre son verdaderos .

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

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 comprenderlo usted mismo (si le importan tales cosas):

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

Esto, por supuesto, supone que se está ejecutando en un navegador (donde windowes un nombre para el objeto global). Pero si estás jugando con globals como este, probablemente estés en un navegador. Subjetivamente, usar 'name' in windowes estilísticamente consistente con usar window.namepara referirse a los globales. El acceso a los globales como propiedades de las windowvariables, en lugar de hacerlo como variables, le permite minimizar el número de variables no declaradas a las que hace referencia en su código (en beneficio de la alineación), y evita la posibilidad de que su variable global sea sombreada por una variable local. Además, si los glóbulos hacen que su piel se erice, es posible que se sienta más cómodo al tocarlos solo con este palo relativamente largo.

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

elem != null

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

Las otras verificaciones tampoco son incorrectas, solo tienen diferentes usos:

• if (elem): Se puede utilizar si elemse garantiza que sea un objeto, o si false, 0, etc. se consideran valores "por defecto" (por lo tanto equivalente a undefinedo null).

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

  • Esta es la única comprobación que no arrojará un error si elemno se declara (es decir var, no hay una declaración, no es una propiedad windowo no es un argumento de función). Esto es, en mi opinión, bastante peligroso ya que permite que los errores tipográficos pasen desapercibidos. Para evitar esto, vea el siguiente método.

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

if (elem === undefined) ...

Sin embargo, debido a que el global undefinedse puede anular con otro valor, es mejor declarar la variable undefineden el alcance 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 undefinedvariable a un solo carácter, ahorrándole unos pocos bytes cada vez.

Comprueba si window. hasOwnProperty( " varname" )

Una alternativa a la gran cantidad de typeofrespuestas;

Variables globales declaradas con una var varname = value;declaración en el alcance global

Se puede acceder como propiedades del objeto de ventana.

Como tal, el hasOwnProperty()método, que

devuelve un valor booleano que indica si el objeto tiene la propiedad especificada como su propia propiedad (en lugar de heredarla)

puede usarse para determinar si

a varde "varname" ha sido declarado globalmente, es decir, es una propiedad de window.

// 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
] );

Lo bueno de esto hasOwnProperty()es que al llamarlo, no usamos una variable que aún no esté declarada, lo que, por supuesto, es la mitad del problema en primer lugar.

Aunque no siempre es la solución perfecta o ideal , en ciertas circunstancias, ¡es solo el trabajo!

Notas

Lo anterior es cierto cuando se usa varpara definir una variable , en oposición a la letcual:

declara una variable local de ámbito de bloque, opcionalmente inicializándola en un valor.

es diferente a la varpalabra clave, que define una variable globalmente o localmente para una función completa, independientemente del alcance del bloque.

En el nivel superior de programas y funciones, a letdiferencia de esto var, no crea una propiedad en el objeto global.

Para completar: las const constantes, por definición, no son realmente variables (aunque su contenido puede serlo); más relevante:

Las constantes globales no se convierten en propiedades del objeto de ventana, a diferencia de las varvariables. Se requiere un inicializador para una constante; es decir, debe especificar su valor en la misma declaración en la que se declara.

El valor de una constante no puede cambiar mediante la reasignación, y no se puede volver a declarar.

La declaración const crea una referencia de solo lectura a un valor. No significa que el valor que posee es inmutable, solo que el identificador de variable no se puede reasignar.

Dado que las letvariables o constconstantes nunca son propiedades de ningún objeto que haya heredado el hasOwnProperty()método, no se puede usar para verificar su existencia.

En cuanto a la disponibilidad y uso de hasOwnProperty():

Cada objeto que desciende de Object hereda el hasOwnProperty()método. [...] a diferencia del inoperador, este método no verifica la cadena prototipo del objeto.

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 determinada variable no se haya inicializado:

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

Problemas con la encapsulación

Desafortunadamente, no puede simplemente encapsular su 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 la variable foono se ha definido, porque no puede pasar una variable no existente a una función:

Error de referencia no capturado: foo no está definido

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

Si bien nuestra issetfunción no se puede usar para probar si una variable existe o no (por las razones explicadas anteriormente), nos permite probar 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 yse transfiere ningún valor a la función test, nuestra issetfunción funciona perfectamente en este contexto, porque yse conoce en la función testcomo un undefinedvalor.

Hay otra forma abreviada de verificar esto, cuando realiza tareas simples y verificaciones relacionadas. Simplemente use el operador condicional (ternario).

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

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

Si desea verificar la variable no debe ser undefinedonull . Luego realice la verificación a continuación.

Cuando se declara la variable, y si desea verificar el valor, esto es incluso Simple: y se realizaría undefinedy nullverificaría en conjunto.

var values = variable ? variable : '';

La forma corta de probar una variable no se declara (no está indefinida) es

if (typeof variable === "undefined") {
  ...
}

Lo encontré útil para detectar secuencias de comandos que se ejecutan fuera de un navegador (sin haber declarado la windowvariable).

Depende si solo le importa que la variable se haya definido o si desea que tenga un valor significativo.

Al verificar si el tipo no está definido, se verificará si la variable ya se ha definido.

=== nullo !== nullsolo verificará si el valor de la variable es exactamentenull .

== nullo != nullcomprobará si el valor es undefinedonull .

if(value)comprobará si la variable es 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 era que en JavaScript undefinedes mutable (por alguna razón impía). Por lo tanto, simplemente hacer una verificación de varName !== undefinedtiene el potencial de no siempre regresar como lo espera, porque otras bibliotecas podrían haber cambiado indefinidamente. Algunas respuestas (@ skalee, por ejemplo), parecen preferir no usartypeof , y eso podría en problemas.

La forma "antigua" de manejar esto era declarar indefinido como var para compensar cualquier posible silenciamiento / anulación undefined. Sin embargo, la mejor manera es usarlo typeofporque ignorará cualquier anulación de undefinedotro código. Especialmente si está escribiendo código para usar en la naturaleza donde quién sabe qué más podría estar ejecutándose 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 que siempre prefiero if (!variable), compruebe si es falsa. 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); 
}

.. podría reducirse a:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  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);

Nulo es un valor en JavaScript y typeof nulldevuelve"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
}

La verificación más robusta "está definido" es con typeof

if (typeof elem === 'undefined')

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

elem = elem || defaultElem;

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

También existe este forro con la palabra clave typeof :

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

puedes usar el typeof operador.

Por ejemplo,

var dataSet;

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

El fragmento de código anterior devolverá la salida como

conjunto de datos variable es: indefinido.

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

No he encontrado una manera de extraer el código a 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");
}

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

Supongamos que necesito variableName;que lleve un undefinedvalor y, por lo tanto, se ha declarado de una manera tal var variableName;que significa que ya está inicializado ; - ¿Cómo verifico si ya está declarado?

O incluso mejor: ¿cómo verifico de inmediato si "Book1.chapter22.paragraph37" existe con una sola llamada, pero no surge un error de referencia?

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

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

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

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

En la situación particular descrita en la pregunta,

typeof window.console === "undefined"

es idéntico a

window.console === undefined

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

Tenga en cuenta que solo buscamos consoleen el ámbito global (que es un windowobjeto en todos los navegadores). En esta situación particular es deseable. No queremosconsole definirse en otra parte.

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

Yo uso 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 este caso

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Si necesita lo contrario, en primera instancia, ¡variable se convierte en variable, y en la función no válida === se convierte! = Y los nombres de las funciones cambian a notInvalid.

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

Sin importar cómo elija, considere poner el cheque en una función como esta

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;

Cuando sepa que la variable está declarada pero puede no existir, puede usar

existy(elem) && doSomething(elem);

La variable que está comprobando puede ser una propiedad anidada a veces. Puedes usar prop || {} para ir más abajo comprobando 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 podrías usar existy como existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Depende de la situación. Si está buscando algo que puede o no haberse definido globalmente fuera de su código (tal vez jQuery quizás) desea:

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 haberse pasado, siempre se definirán, pero serán nulos si se omiten.

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

Trata de atraparlo

Si la variable no se definió en absoluto, puede verificar esto sin la ejecución del código de interrupción usando el bloque try-catch de la siguiente manera (no necesita use strictmodo)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BONIFICACIÓN: (refiriéndose a otras respuestas) ¿Por qué ===es más claro que ==( fuente )

si (a == b)

si (a === b)

Me sorprende que esto no haya sido mencionado todavía ...

Aquí hay un par de variaciones adicionales usando this['var_name']

El beneficio de usar este método es que puede usarse antes de definir una variable.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

Podrías usar un try ... catch block como el siguiente:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Una desventaja es que no puede ponerlo en una función, ya que arrojaría un ReferenceError

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))