¿Quieres typeof operador. Específicamente:

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

LA typeof El operador comprobará si la variable es realmente indefinida.

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

LA typeof operador, a diferencia de los otros operadores, no lanza un Error de referencia excepción cuando se usa con una variable no declarada.

Sin embargo, tenga en cuenta que typeof null regresará "object". Debemos tener cuidado para evitar el error de inicializar una variable para 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 una comparación estricta === en lugar de simple igualdad ==, Consulte:
¿Qué operador de igual (== vs ===) debe usarse en las comparaciones de JavaScript?

En muchos casos, usar:

if (elem) { // or !elem

¡hará el trabajo por usted! ... esto verificará estos casos a continuación:

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

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. ' ' uno, esto se definirá en javascript ya que tiene espacios dentro de la cadena ... por ejemplo, en este caso, agrega una verificación más usando trim (), como:

if(elem) {

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

Además, estos controles son para valores solo, como los objetos y las matrices funcionan de manera diferente en Javascript, la matriz vacía [] y objeto vacío {} son siempre verdadero.

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 preocupan esas cosas):

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

Esto, por supuesto, asume que está ejecutando en un navegador (donde window es un nombre para el objeto global). Pero si estás jugando con globales como este, probablemente estés en un navegador. Subjetivamente, usando 'name' in window es estilísticamente consistente con el uso window.name para referirse a globales. Accediendo a globales como propiedades de window en 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 interferencia), y evita la posibilidad de que su global sea ensombrecido por una variable local. Además, si los globals hacen que su piel se erice, es posible que se sienta más cómodo tocándolos solo con este palo relativamente largo.

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

elem != null

A diferencia de un simple if (elem), Permite 0, false, NaN e '', pero rechaza null or undefined, lo que la convierte en una buena prueba general de la presencia de un argumento o propiedad de un objeto.

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

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

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

  • Este es el único cheque que no arrojará un error if elem no es declaró (es decir, no var declaración, no una propiedad de window, o no un argumento de función). En mi opinión, esto es bastante peligroso, ya que permite que los errores tipográficos pasen desapercibidos. Para evitar esto, consulte el método siguiente.

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

if (elem === undefined) ...

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

Comprobar si window.hasOwnProperty("varname")

Una alternativa a la plétora de typeof respuestas;

Buscar variables declaradas con un var varname = value; declaración en el ámbito global

se puede acceder como propiedades del objeto de ventana.

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

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

se puede utilizar para determinar si

a var of "varname" ha sido declarado globalmente es decir, es una propiedad del 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 cual, por supuesto, es la mitad del problema en primer lugar.

Aunque no siempre Perfecto or ideal solución, en determinadas circunstancias, ¡es solo el trabajo!

Notas

Lo anterior es cierto cuando se usa var para definir una variable, Opuesto a let cual:

declara una variable local de alcance de bloque, inicializándola opcionalmente a un valor.

es diferente al var palabra clave, que define una variable globalmente o localmente a una función completa independientemente del alcance del bloque.

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

Por completitud: const las 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 var variables. 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 tiene sea inmutable, solo que el identificador de variable no se puede reasignar.

Como let variables o const Las constantes nunca son propiedades de ningún objeto que haya heredado la hasOwnProperty() método, no se puede utilizar para comprobar su existencia.

Respecto a la disponibilidad y uso de hasOwnProperty():

Cada objeto descendió de Objeto hereda el hasOwnProperty() método. [...] a diferencia del in operador, este método no comprueba la cadena del prototipo del objeto.

Cómo comprobar si existe una variable

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

var setOrNot = typeof variable !== typeof undefined;

Se utiliza con mayor frecuencia 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.

Podría 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 puede pasar una variable inexistente a una función:

Error de referencia no detectado: foo no está definido

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

Mientras nuestro isset La funció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 tiene valor para y se transmite a la función test, nuestra isset La función funciona perfectamente en este contexto, porque y es conocido en función test como una undefined .

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

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

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

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

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

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

Si quisiera verificar la variable no debería ser undefined or null. Luego realice la siguiente verificación.

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

var values = variable ? variable : '';

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.

=== null or !== null solo comprobará si el valor de la variable es exactamente null.

== null or != null comprobará si el valor es undefined or null.

if(value) comprobará si la variable es undefined, null, 0o 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 undefined es mutable (por alguna razón impía). Así que simplemente verificando varName !== undefined tiene el potencial de no regresar siempre como se esperaba, porque otras librerías podrían haber cambiado de forma indefinida. Algunas respuestas (@ skalee's, por ejemplo), parecen preferir no usar typeof, y eso podría causarle problemas.

La forma "antigua" de manejar esto era declarar indefinido como var para compensar cualquier posible silenciamiento / anulación de undefined. Sin embargo, la mejor forma sigue siendo utilizar typeof porque ignorará cualquier anulación de undefined de otro 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.

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 use strict modo)

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');

BONUS: (refiriéndose a otras respuestas) ¿Por qué? === es mas claro que == (fuente)

si (a == b)

si (a === b)

Para contribuir al debate, si sé que la variable debe ser una cadena o un objeto, siempre prefiero if (!variable), así que comprobando 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); 
}

..podría reducirse a:

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

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

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 en 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);

Utilizo dos formas diferentes según el 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, entonces, en primera instancia,! Variable se convierte en !! variable, y en la función no válida === se convierte en! = Y el nombre de la función cambia a notInvalid.

La comprobación más robusta de 'está definido' es con tipo de

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 de usar, consulte: Manera idiomática de establecer el valor predeterminado en javascript

También existe este delineador que usa el tipo de palabra clave:

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

se puede utilizar el typeof operador.

Por ejemplo,

var dataSet;

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

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

variable dataSet es: indefinido.

Para verificar si una variable ha sido declarada / configurada, 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");
}

En la situación particular descrita en la pregunta,

typeof window.console === "undefined"

es idéntico a

window.console === undefined

Prefiero este último porque es más corto.

Tenga en cuenta que buscamos console sólo en el ámbito global (que es un window objeto en todos los navegadores). En esta situación particular es deseable. No queremos console definido en otro lugar.

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

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

Independientemente de lo que 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;

Donde sepa que la variable está declarada pero puede que no exista, puede usar

existy(elem) && doSomething(elem);

La variable que está comprobando puede ser una propiedad anidada a veces. Puedes usar prop || {} para seguir la línea 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 haber sido definido globalmente fuera de su código (como jQuery quizás), desea:

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

(No hay necesidad de una igualdad estricta allí, typeof siempre devuelve una cadena). Pero si tiene argumentos para una función que pueden o no haber sido pasados, 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"

Atención: personas que no entienden la diferencia entre un valor. let, constante const y variable var deben abstenerse de comentar.

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

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

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

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

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

En tiempos de máxima popularidad de AJAX, escribí un método (luego 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 dado que ha sido publicado anteriormente y debido a su gran importancia, merece ser publicado en un hilo aparte, no lo publicaré aquí sino que proporcionaré palabras clave (javascript + esNS ) que le ayudará a localizar el código fuente, respaldado con todas las explicaciones necesarias.

if (variable === undefined) {}

funciona bien y solo comprueba si no está definido.

Podría usar un bloque try ... catch 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))

Edit:

Si estaba trabajando en Javascript front-end y necesitaba verificar si una variable no se inicializó (var x = undefined contará como no inicializado), puede usar:

function globalVariableExists(variable) {
  if (window[variable] != undefined) {
    return true
  }
  
  return false
}

var x = undefined

console.log(globalVariableExists("x"))

console.log(globalVariableExists("y"))

var z = 123

console.log(globalVariableExists("z"))

Editar 2:

Si necesita verificar si existe una variable en el alcance actual, simplemente puede pasar this a la función, junto con el nombre de la variable contenida en una cadena:

function variableExists(variable, thisObj) {
  if (thisObj[variable] !== undefined) {
    return true
  }
  
  return false
}

class someClass {
  constructor(name) { 
    this.x = 99
    this.y = 99
    this.z = 99
    this.v = 99
    
    console.log(variableExists(name, this))
  }
}

new someClass('x')
new someClass('y')
new someClass('z')
new someClass('v')
new someClass('doesNotExist')

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

aquí hay un par de variaciones adicionales que usan this['var_name']

La ventaja de utilizar este método es que se puede utilizar 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!

In Reaccionar, ¡las cosas son un poco más complicadas! Esto se debe a que es un entorno compilado, que sigue ESLint's no-undef regla desde react-scripts@2.0.3 (liberado 1 de octubre de 2018). La documentación aquí es útil para cualquier persona interesada en este problema ...

En JavaScript, antes de ES6, las declaraciones de variables y funciones se elevan a la parte superior de un alcance, por lo que es posible usar identificadores antes de sus declaraciones formales en código ...

Esta [nueva] regla [de ES6] advertirá cuando encuentre una referencia a un identificador que aún no ha sido declarado.

Entonces, si bien es posible tener una undefined (o "no inicializada") variable, es imposible tener una variable no declarada en ReactJS sin desactivar las reglas de eslint.

Esto puede ser muy frustrante: hay tantos proyectos en GitHub que simplemente aprovechan los estándares anteriores a ES6; y compilarlos directamente sin ningún ajuste es básicamente imposible.

Pero, para ReactJS, puedes usar eval(). Si tiene una variable no declarada como ...

if(undeclaredvar) {...}

Simplemente puede reescribir esta parte como ...

if(eval('typeof undeclaredvar !== "undefined"')) {...}

Por ejemplo ...

if(eval("false")) {
  console.log("NO!");
}
if(eval("true")) {
  console.log("YEAH!");
}

Para aquellos que importan repositorios de GitHub en un proyecto ReactJS, esta es simplemente la única forma de verificar si una variable está declarada. Antes de cerrar, me gustaría recordarles que hay problemas de seguridad con eval() si se usa incorrectamente.

Prefiero este método por su precisión y concisión:

var x
if (x === void 0) {
  console.log(`x is undefined`)
} else {
  console.log(`x is defined`)
}

Como se ha mencionado en otros comentarios y respuestas, undefined no se garantiza que sea indefinido. Debido a que no es una palabra clave, se puede redefinir como una variable en ámbitos distintos al ámbito global. Aquí hay un pequeño ejemplo que demuestra este matiz:

var undefined = 'bar'
console.log(`In the global scope: ${undefined}`)

function foo() {
  var undefined = 'defined'
  var x
  if (x === undefined) {
    console.log(`x === undefined`)
  } else {
    console.log(`x !== undefined`)
  }
  if (x === void 0) {
    console.log(`x === void 0`)
  } else {
    console.log(`x !== void 0`)
  }
}

foo()

Ver vacío por compatibilidad (compatible con IE5!? !! ¡Guau!).

También puedes usar !! antes de una variable para comprobar si está definida. P.ej

let dog = "woof";
let chineseCat; // Undefined.
console.log("1.");
console.log(!!dog && !!chineseCat ? "Both are defined" : "Both are NOT defined");

chineseCat= "mao"; // dog and chineseCat are now defined.
console.log("2.");
console.log(!!dog && !!chineseCat ? "Both are defined" : "Both are NOT defined");

Salida:

1.
Both are NOT defined
2. 
Both are defined