Cómo verificar una variable no definida en JavaScript

Quería verificar si la variable está definida o no. Por ejemplo, lo siguiente arroja un error no definido

alert( x );

¿Cómo puedo detectar este error?

En JavaScript, nulles un objeto. Hay otro valor para las cosas que no existen, undefined. El DOM regresa nullpara casi todos los casos en los que no puede encontrar alguna estructura en el documento, pero en JavaScript undefinedes el valor utilizado.

Segundo, no, no hay un equivalente directo. Si realmente desea verificar específicamente null, haga lo siguiente:

if (yourvar === null) // Does not execute if yourvar is `undefined`

Si desea verificar si existe una variable, eso solo se puede hacer con try/ catch, ya typeofque tratará una variable no declarada y una variable declarada con el valor de undefinedcomo equivalente.

Pero, para verificar si una variable se declara y no es undefined:

if (yourvar !== undefined) // Any scope

Anteriormente, era necesario utilizar el typeofoperador para verificar indefinidamente, porque era posible reasignar undefinedcomo una variable. La vieja forma se veía así:

if (typeof yourvar !== 'undefined') // Any scope

El problema de undefinedser reasignable se solucionó en ECMAScript 5, que se lanzó en 2009. Ahora puede usar ===y !==probar de forma segura undefinedsin usar, typeofya que undefinedha sido de solo lectura durante algún tiempo.

Si desea saber si un miembro existe independientemente pero no le importa cuál es su valor:

if ('membername' in object) // With inheritance
if (object.hasOwnProperty('membername')) // Without inheritance

Si quieres saber si una variable es verdadera :

if (yourvar)

Fuente

La única forma de probar realmente si una variable es undefinedhacer lo siguiente. Recuerde, indefinido es un objeto en JavaScript.

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

Algunas de las otras soluciones en este hilo lo llevarán a creer que una variable no está definida aunque haya sido definida (con un valor de NULL o 0, por ejemplo).

Técnicamente, la solución adecuada es (creo):

typeof x === "undefined"

A veces puedes ponerte perezoso y usar

x == null

pero eso permite que tanto una variable indefinida x, como una variable x que contenga nulo, devuelvan verdadero.

Una versión aún más fácil y más abreviada sería:

if (!x) {
   //Undefined
}

O

if (typeof x !== "undefined") {
    //Do something since x is defined.
}

A menudo he hecho:

function doSomething(variable)
{
    var undef;

    if(variable === undef)
    {
         alert('Hey moron, define this bad boy.');
    }
}

También puede usar el operador condicional ternario:

var a = "hallo world";
var a = !a ? document.write("i dont know 'a'") : document.write("a = " + a);

//var a = "hallo world";
var a = !a ? document.write("i dont know 'a'") : document.write("a = " + a);

A menudo uso la forma más simple:

var variable;
if (variable === undefined){
    console.log('Variable is undefined');
} else {
    console.log('Variable is defined');
}

EDITAR:

Sin inicializar la variable, se generará una excepción "Error de referencia no capturado: la variable no está definida ..."

Otra posible "solución" es usar el windowobjeto. Evita el problema de error de referencia en un navegador.

if (window.x) {
    alert('x exists and is truthy');
} else {
    alert('x does not exist, or exists and is falsy');
}

¡El error te dice que xni siquiera existe! No se ha declarado , lo que es diferente de que se le asigne un valor.

var x; // declaration
x = 2; // assignment

Si declaras x, no obtendrás un error. Recibiría una alerta que dice undefinedporque xexiste / ha sido declarado pero no se le ha asignado un valor.

Para verificar si la variable ha sido declarada, puede usar typeofcualquier otro método para verificar si existe una variable generará el mismo error que obtuvo inicialmente.

if(typeof x  !==  "undefined") {
    alert(x);
}

Esto verifica el tipo de valor almacenado en x. Solo volverá undefinedcuando xno se haya declarado O si se ha declarado y aún no se ha asignado.

El voidoperador regresa undefinedpor cualquier argumento / expresión que se le pase. para que pueda probar el resultado (en realidad, algunos minificadores cambian su código de undefineda void 0para guardar un par de caracteres)

Por ejemplo:

void 0
// undefined

if (variable === void 0) {
    // variable is undefined
}

Podemos comprobar de la undefinedsiguiente manera

var x; 

if (x === undefined) {
    alert("x is undefined");
} else {
     alert("x is defined");
}

Solo haz algo como a continuación:

function isNotDefined(value) {
  return typeof value === "undefined";
}

y lo llaman así:

isNotDefined(undefined); //return true
isNotDefined('Alireza'); //return false

La respuesta aceptada es correcta. Solo quería agregar una opción más. También puede usar el try ... catchbloqueo para manejar esta situación. Un ejemplo extraño:

var a;
try {
    a = b + 1;  // throws ReferenceError if b is not defined
} 
catch (e) {
    a = 1;      // apply some default behavior in case of error
}
finally {
    a = a || 0; // normalize the result in any case
}

Tenga en cuenta el catchbloqueo, que es un poco desordenado, ya que crea un alcance a nivel de bloque. Y, por supuesto, el ejemplo está extremadamente simplificado para responder la pregunta, no cubre las mejores prácticas en el manejo de errores;).

Utilizo una pequeña función para verificar que se haya declarado una variable, lo que realmente reduce la cantidad de desorden en mis archivos javascript. Agrego un cheque para el valor para asegurarme de que la variable no solo exista, sino que también se le haya asignado un valor. La segunda condición verifica si la variable también ha sido instanciada, porque si la variable ha sido definida pero no instanciada (vea el ejemplo a continuación), todavía arrojará un error si intenta hacer referencia a su valor en su código.

No instanciado - var my_variable;Instantado -var my_variable = "";

function varExists(el) { 
  if ( typeof el !== "undefined" && typeof el.val() !== "undefined" ) { 
    return true; 
  } else { 
    return false; 
  } 
}

Luego puede usar una declaración condicional para probar que la variable ha sido definida Y instanciada de esta manera ...

if ( varExists(variable_name) ) { // checks that it DOES exist } 

o para probar que no se ha definido y uso instanciado ...

if( !varExists(variable_name) ) { // checks that it DOESN'T exist }