Quieres el operador typeof . Específicamente:

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

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 tus 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 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 window es un nombre para el global objeto). Pero si estás jugando con globals como este, probablemente estés en un navegador. Subjetivamente, usar 'name' in window es estilísticamente consistente con usar window.name para referirse a los globales. Acceder a los 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 linting), y evita la posibilidad de que su global sea sombreado por una variable local. Además, si los globals hacen que tu piel se ponga gatera, podrías sentir más cómodo tocarlos solo con este palo relativamente largo.

En la mayoría de los casos utilizarí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.

Las otras comprobaciones tampoco son incorrectas, solo que tienen diferentes usos:

• if (elem): se puede utilizar si se garantiza que elem es un objeto, o si false, 0, etc. se consideran valores" predeterminados " (por lo tanto equivalente 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 comprobación de que no arrojará un error si elem no es declarado (es decir, no var declaración, no una propiedad de window, o no 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 lo siguiente método.

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

if (elem === undefined) ...

Sin embargo, debido a que el global undefined se puede sobrescribir con otro valor, es mejor declarar la variable undefined en el ámbito actual antes de usarla:

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 solo carácter, ahorrándole unos pocos bytes cada vez.

En muchos casos, usando:

if (elem) { // or !elem

Hará el trabajo por ti!... esto comprobará estos casos a continuación:

1. undefined : si el valor no está definido y es undefined
2. null: si es null, 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. false

Así que cubrirá todo tipo de casos, pero siempre hay casos extraños que nos gustaría cubrir también, 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 agregas una comprobación 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 los arrays funcionan de manera diferente en Javascript, el array vacío [] y el objeto vacío {} siempre son verdaderos.

Creo la imagen de abajo para mostrar un breve resumen de la respuesta:

Cómo comprobar 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.

Usted 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 eg. isset(foo) y variable foo no se ha definido, porque no se puede pasar una variable inexistente a una función:

Uncaught ReferenceError: foo no está definido

Probando si los parámetros de la función son indefinidos

Mientras que nuestra función isset 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 son indefinidos :

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

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

Compruebe si un objeto hasOwnProperty()

Una alternativa a la plétora de typeof respuestas, es el uso de hasOwnProperty() que por supuesto comprueba si un objeto (casi todo en JS) tiene una propiedad es decir, una variable (entre otras cosas).

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

Cada objeto descendiente de Objeto hereda el método hasOwnProperty(). Este método se puede usar para determinar si un objeto tiene la propiedad especificada como una propiedad directa de ese objeto; a diferencia del operador en, este método no comprueba la cadena prototipo 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
] );

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

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

Hay otra forma corta de verificar esto, cuando realiza tareas simples y comprobaciones relacionadas. Simplemente use 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 comprobar variable no debe ser undefined o null. A continuación, realice la comprobación a continuación.

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

var values = variable ? variable : '';

Undefined,boolean,string,number, function

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

}

Objeto, Matriz

if( foo instanceof Array ) { 

}

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

Al comprobar si el tipo no está definido se comprobará si la variable ya está definida.

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

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

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 es que en JavaScript undefined es mutable (por alguna razón impía). Así que simplemente hacer una comprobación para varName !== undefined tiene el potencial de no volver siempre como esperas, porque otras libs podrían haber cambiado indefinidamente. Algunas respuestas (@skalee's, por ejemplo), parecen preferir no usar typeof, y eso podría meternos en problemas.

La forma "antigua" de manejar esto era declarar undefined como un var para compensar cualquier potencial muting / over-riding de undefined. Sin embargo, la mejor manera sigue siendo usar typeof porque ignorará cualquier sobreescritura de undefined de otro código. Especialmente si está escribiendo código para usarlo 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, siempre prefiero if (!variable), así que verifique 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)
} 

Es difícil distinguir entre indefinido y nulo. Null es un valor que puede asignar a una variable cuando desea indicar que la variable no tiene ningún 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);

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 comprobación adicional para 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 que mi variableName; lleve un valor undefined, y por lo tanto ha sido declarado de una manera como var variableName;lo que significa que ya está inicializado; - ¿Cómo compruebo si ya está declarado?

O incluso mejor - ¿cómo puedo comprobar inmediatamente si "Book1.capítulo 22.paragraph37 " existe con una sola llamada, pero no subir un error de referencia?

Lo hacemos usando la mayoría potente operador JasvaScript, el operador in.:

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

En tiempos de 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.capítulo 22.paragraph37" y mucho más.

Pero ya que 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 le ayudará a localizar el código fuente, respaldado con todas las explicaciones necesarias.

La comprobación 'is it defined' más robusta es con typeof

if (typeof elem === 'undefined')

Si solo está comprobando 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 usarlo, consulte: Forma idiomática de establecer el valor predeterminado en javascript

También hay este liner usando la palabra clave typeof:

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

Puede usar el operador typeof.

Por ejemplo,

var dataSet;

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

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

El conjunto de datos variable es : undefined.

En la situación particular esbozada en la pregunta,

typeof window.console === "undefined"

Es idéntico a

window.console === undefined

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

Tenga en cuenta que buscamos console solo en el ámbito global (que es un objeto window 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. Sólo he añadido falta de conclusión y digerido en algo más fácil Leer.

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

Como quiera 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 sabes que la variable está declarada pero puede que no exista, puedes usar

existy(elem) && doSomething(elem);

La variable que está comprobando puede ser una propiedad anidada a veces. Puede usar prop / / {} para bajar 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 uso de la propiedad (...' || {}').nextProp para que una propiedad faltante no genere un error.

O podrías usar existy como existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Si desea que el bloque definido haga algo, use este

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

Si desea que undefined block haga algo o asigne o defina la variable, use 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, por lo que uso este caso

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

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

Si usted necesita lo contrario, entonces en primera instancia !variable se convierte !!variable, y en la función inválida = = = convertirse != y los nombres de las funciones cambian a notInvalid.

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 igualdad estricta allí, typeof siempre devuelve una cadena.) Pero si tiene argumentos para una función que puede o no haber sido pasada, siempre se definirán, pero null si se omite.

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á cierto si existe, otra cosa falso si no existe.

¿Qué pasa con un simple:

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

Tenga en cuenta que cuando usted comprueba !== o != contra "indefinido" no funcionará

Probado en Firfox Quantom 60.0.1

Use 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 comprobar 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");
}

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á verdadero iff x es null o undefined , así que !!x solo devolverá true si x no es indefinido ni nulo.

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