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




variable undefined javascript (19)

¿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) {

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!


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 .


Depende de la situación. Si está verificando algo que puede o no haber sido definido globalmente fuera de su código (como jQuery tal vez) usted desea:

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

(No es necesario que exista una igualdad estricta, typeof siempre devuelve una cadena). Pero si tiene argumentos para una función que pueden o no haber sido aprobados, siempre se definirán, pero nulos si se omiten.

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

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

Al verificar si el tipo no está definido, se verificará si la variable se ha definido todavía.

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

== null o != null verificará si el valor undefined está undefined o es null .

if(value) comprobará si la variable es undefined , null , 0 o una cadena vacía.


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 facilita la descripción precisa del comportamiento de su código y su comprensión (si le interesan estas 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 objeto global). Pero si estás jugando con gente como esta, probablemente estés en un navegador. Subjetivamente, usar 'name' in window es estilísticamente consistente con usar window.name para referirse a globales. El acceso a las variables globales como propiedades de window lugar de 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 alineación), y evita la posibilidad de que su variable global se vea afectada por una variable local. Además, si los globos globales hacen que tu piel se arrastre, quizás te sientas más cómodo al 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 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.


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:


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


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

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;

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)


No puedo ver esto en las respuestas anteriores, así que lo sugiero aquí, supongo.

function isDefined(x) { return !!x }

if( isDefined(x) ) {
    //The variable is defined
}

! x devolverá verdadero si x es nulo o no definido , entonces! x solo devolverá verdadero 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 sobre eso.


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)
} 


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

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
}

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.


Usted quiere el operador typeof . Específicamente:

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

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

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

}

Objeto, Array

if( foo instanceof Array ) { 

}

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

O mejor

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

Funciona en todos los navegadores.





undefined