variables error - JavaScript verifica si la variable existe(está definida / inicializada)




validar jquery (24)

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

Como quiera que elija, considere poner la marca 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 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 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 propiedad (... '|| {}'). NextProp para que una propiedad faltante no arroje un error.

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

¿Qué método de 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) {

Si quieres que el bloque definido haga algo, usa este

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

Si desea que un bloque indefinido haga algo o asigne o defina la variable, use este

if (typeof variable === 'undefined') {
    // the variable is 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 la console definida en otro lugar.

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


En muchos casos, utilizando:

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 no está undefined
  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

Así que cubrirá la clase de todos los casos, pero siempre hay casos extraños que nos gustaría cubrir también, 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, agregue 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 de abajo para mostrar un breve resumen de la respuesta:


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

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

La función devolverá verdadero si existe, o falso si no existe.


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 ha sido declarado de una manera tal como var variableName; lo que significa que ya está inicializado ; - ¿Cómo compruebo si ya está declarado?

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

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

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

En momentos de gran popularidad de AJAX, he escrito un método (denominado más tarde) isNS () que es capaz de determinar si existe el espacio de nombres, incluidas pruebas exhaustivas para nombres de propiedades como "Book1.chapter22.paragraph37" y mucho más.

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


¿Qué pasa con un simple:

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

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 de la presencia de un argumento o propiedad de un objeto.

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

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

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

    • Esta es la única comprobación que no arrojará un error si no se declara elem (es decir, no hay una declaración var , no es una propiedad de window , o no es un argumento de función). Esto es, en mi opinión, bastante peligroso, ya que permite que los errores tipográficos pasen inadvertidos. 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 valor global undefined se puede anular con otro valor, es mejor declarar la variable undefined en el alcance 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 mineros JS pueden reducir la variable undefined a un solo carácter, ahorrando unos cuantos bytes cada vez.


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

O mejor

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

Funciona en todos los navegadores.


Puede utilizar 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: 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");
}

Usted quiere el operador typeof . Específicamente:

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

Tenga en cuenta que cuando verifique! == o! = Contra "indefinido" no funcionará

Probado en Firfox Quantom 60.0.1

Utilice la prueba de esta manera 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");
        }

indefinido, booleano, cadena, número, función

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

}

Objeto, Array

if( foo instanceof Array ) { 

}

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, entonces, en la primera instancia, la variable se convierte en variable, y en la función no válida === se convierte en = y los nombres de las funciones cambian a notInvalid.


Hay otra forma breve de verificar esto cuando realiza tareas simples y verificaciones relacionadas. Simplemente use Operador Condicional (Ternario).

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

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

Si desea comprobar la variable no debe estar undefined o null . Luego realice el siguiente cheque.

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

var values = variable ? variable : '';

Para contribuir al debate, si sé que la variable debe ser una cadena o un objeto, siempre prefiero if (!variable) , así que compruebe si es falsa. Esto puede llevar a más código 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 ser reducido 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 quiere indicar que la variable no tiene un valor particular. No definido 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);


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.

Podrías 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 foo no se han definido, porque no puede pasar una variable no existente a una función:

Error de referencia no detectado: foo no está definido

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

Si bien nuestra función de isset no se puede usar para probar si existe una variable o no (por 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 se pasa ningún valor para y a la test función, nuestra función de isset funciona perfectamente en este contexto, ya que y en la test función se conoce como un valor undefined .


La comprobación más robusta de 'se define' es con typeof

if (typeof elem === 'undefined')

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

elem = elem || defaultElem;

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

También existe este liner que usa la palabra clave typeof :

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

Compruebe si un objeto tiene hasOwnProperty()

Una alternativa a la gran cantidad de respuestas tipo, es el uso de hasOwnProperty() que, por supuesto, verifica si un objeto (casi 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 una propiedad directa de ese objeto; a diferencia del operador in , este método no comprueba la cadena del 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 utilizamos una variable que aún no esté definida, lo que, desde luego, es la mitad del problema.

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


El operador typeof verificará si la variable es realmente indefinida.

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" . Tenemos que tener cuidado de evitar el error de inicializar una variable a 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 === lugar de la igualdad simple == , consulte:
¿Qué operador igual (== vs ===) se debe usar en las comparaciones de JavaScript?


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 los valores nulos:

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

Ejemplo para el primer punto por dlaliberte:

Un cierre no solo se crea cuando devuelves una función interna. De hecho, la función de encerramiento no necesita regresar en absoluto. En su lugar, puede asignar su función interna a una variable en un ámbito externo, o pasarla como un argumento a otra función en la que podría usarse de inmediato. Por lo tanto, el cierre de la función de encierro probablemente ya existe en el momento en que se llamó a la función de encierro, ya que cualquier función interna tiene acceso a ella tan pronto como se llama.

var i;
function foo(x) {
    var tmp = 3;
    i = function (y) {
        console.log(x + y + (++tmp));
    }
}
foo(2);
i(3);




javascript variables if-statement initialization undefined