validar - variable null javascript

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

Question

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

Answer 1

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!

Answer 2

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 .

Answer 3

¿Qué pasa con un simple:

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

Answer 4

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"

Answer 5

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.

Answer 6

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?

Answer 7

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.

Answer 8

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.

Answer 9

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.

Answer 10

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:

Answer 11

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

Answer 12

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.

Answer 13

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

Answer 14

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;

Answer 15

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 hacer una comprobación para varName !== undefined tiene el potencial de no siempre devolver como se espera, porque otras librerías podrían haber cambiado sin definir. Algunas respuestas (@ skalee''s, por ejemplo), parecen preferir no usar typeof , y eso podría causar problemas.

La forma "antigua" de manejar esto fue declararse indefinido como var para compensar cualquier muting / over-riding potencial de undefined . Sin embargo, la mejor manera es utilizar typeof porque ignorará cualquier anulación de undefined de otro código. Especialmente si está escribiendo código para su uso en la naturaleza donde quién sabe qué más podría estar ejecutando en la página ...

Answer 16

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)

Answer 17

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.

Answer 18

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
}

Answer 19

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

Answer 20

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

Answer 21

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.

Answer 22

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
}

Answer 23

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.

Answer 24

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.

Answer 25

Usted quiere el operador typeof . Específicamente:

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

Answer 26

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

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

Objeto, Array

if( foo instanceof Array ) { 

}

Answer 27

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

Answer 28

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

O mejor

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

Funciona en todos los navegadores.