Pregunta Verificación de JavaScript si la variable existe (está definida / inicializada)


¿Qué método para verificar si una variable se ha inicializado es mejor / correcto? (Suponiendo que la variable pueda contener algo (cadena, int, objeto, función, etc.))

if (elem) { // or !elem

o

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

o

if (elem != null) {

1281
2018-02-25 03:44


origen


Respuestas:


Usted quiere el typeof operador. Específicamente:

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

2502
2018-02-06 04:56



los typeof el operador verificará si la variable realmente no está definida.

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

los typeof operador, a diferencia de los otros operadores, no arroja un ReferenceError excepción cuando se usa con una variable no declarada.

Sin embargo, tenga en cuenta que typeof null regresará "object". Debemos tener cuidado para evitar el error de inicializar una variable a null. Para estar seguro, 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 === en lugar de simple igualdad ==, ver:
¿Qué operador igual (== vs ===) se debe usar en las comparaciones de JavaScript?


691
2018-06-28 16:00



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 hace que sea más fácil describir con precisión el comportamiento de su código y entenderlo usted mismo (si le importan esas 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 globos como este, probablemente estés en un navegador. Subjetivamente, usando 'name' in window es estilísticamente consistente con el uso window.name para referirse a globales. Accediendo a 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 la pelusa), y evita la posibilidad de que su sombra global sea ensombrecida por una variable local. Además, si los globals hacen que tu piel se arrastre, es posible que te sientas más cómodo si los tocas solo con este bastón relativamente largo.


182
2017-10-22 15:47



En la mayoría de los casos, usarías:

elem != null

A diferencia de un simple if (elem), Permite 0, false, NaN y '', pero rechaza null o undefined, convirtiéndolo en una buena prueba general para la presencia de un argumento o propiedad de un objeto.


Los otros controles tampoco son incorrectos, solo tienen diferentes usos:

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

  • typeof elem == 'undefined' puede ser utilizado en casos donde un null tiene un significado distinto para una variable o propiedad no inicializada.

    • Este es el único cheque que no lanzará 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 inadvertidos. Para evitar esto, mira el siguiente método.

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

if (elem === undefined) ...

Sin embargo, debido a que el global undefinedpuede anularse con otro valor, es mejor declarar la variable undefined en el alcance actual antes de usarlo:

var undefined; // really undefined
if (elem === undefined) ...

O:

(function (undefined) {
    if (elem === undefined) ...
})();

Una ventaja secundaria de este método es que los minificadores de JS pueden reducir la undefined variable a un solo carácter, ahorrándole algunos bytes cada vez.


112
2018-02-25 03:48



En muchos casos, usando:

if (elem) { // or !elem

hará el trabajo por usted! ... esto comprobará estos casos a continuación:

  1. indefinido: si el valor no está definido y es undefined
  2. nulo: si es nulo, por ejemplo, si un elemento DOM no existe ...
  3. cuerda vacía: '' 
  4. 0: Número cero
  5. Yaya: no un número
  6. falso

Por lo tanto, 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, agrega una comprobación más usando trim (), como:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Además, estos controles son para valores solo, ya que los objetos y matrices funcionan de manera diferente en Javascript, array vacío [] y objeto vacío {} son siempre cierto.

Creé la imagen a continuación para mostrar un breve resumen de la respuesta:

undefined, null, etc


80
2017-09-01 06:15



Cómo verificar 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 puedes simplemente encapsular tu cheque en una función.

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

UnEdge ReferenceError: foo no está definido


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

Mientras nuestro isset función no se puede utilizar para probar si existe una variable o no (por las 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 hay valor para y se pasa a lo largo de la función test, nuestra isset la función funciona perfectamente en este contexto, porque y es conocido en funcion test como un undefined valor.


59
2018-02-19 11:54



Verifica si un objeto hasOwnProperty()

Una alternativa a la plétora de typeof respuestas, 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).

los hasOwnProperty() method devuelve un valor booleano que indica si el objeto tiene la propiedad especificada como propiedad propia (no heredada).

Cada objeto desciende de Objeto hereda el hasOwnProperty() método. Este método se puede usar para determinar si un objeto tiene la propiedad especificada como propiedad directa de ese objeto; a diferencia de la en operador, este método no verifica la cadena de prototipos 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 esto hasOwnProperty() es que al llamarlo, no usamos una variable que aún no se ha definido, lo cual, por supuesto, es la mitad del problema en primer lugar.

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


42
2018-05-02 14:07



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

Cuando se declara la variable, y si desea verificar el valor, esto es incluso simple:  y funcionaría undefined y null Controles juntos.

var values = variable ? variable : '';

38
2018-02-19 05:26