vacio - validar variables indefinidas javascript

¿Cómo verificar una variable no definida o nula en JavaScript?

Question

Estamos utilizando con frecuencia el siguiente patrón de código en nuestro código JavaScript

if (typeof(some_variable) != ''undefined'' && some_variable != null)
{
    // Do something with some_variable
}

¿Hay una forma de verificación menos detallada que tenga el mismo efecto?

De acuerdo con algunos foros y publicaciones que dicen simplemente lo siguiente debería tener el mismo efecto.

if (some_variable)
{
    // Do something with some_variable
}

Desafortunadamente, Firebug evalúa tal afirmación como error en el tiempo de ejecución cuando some_variable no está definido, mientras que el primero está bien para eso. ¿Es esto solo un comportamiento (no deseado) de Firebug o hay realmente alguna diferencia entre esas dos formas?

Answer 1

Abra las herramientas del desarrollador en su navegador y pruebe el código que se muestra en la imagen de abajo.

Answer 2

Ambos valores se pueden distinguir fácilmente utilizando el operador de comparación estricta:

Ejemplo de trabajo en:

http://www.thesstech.com/tryme?filename=nullandundefined

Código de muestra:

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}

Answer 3

Como no hay una respuesta completa y correcta, intentaré resumir:

En general, la expresión:

if (typeof(variable) != "undefined" && variable != null)

no se puede simplificar, ya que la variable podría no estar declarada, por lo que omitir el tipo de typeof(variable) != "undefined" daría como resultado un error de referencia. Pero, puedes simplificar la expresión de acuerdo con el contexto :

Si la variable es global , puede simplificar a:

if (window.variable != null)

Si es local , probablemente puede evitar situaciones en las que esta variable no está declarada y también puede simplificar:

if (variable != null)

Si es una propiedad de objeto , no tiene que preocuparse por ReferenceError:

if (obj.property != null)

Answer 4

Como se mencionó en una de las respuestas, puede estar de suerte si está hablando de una variable que tiene un alcance global. Como sabrá, las variables que define globalmente tienden a agregarse al objeto de Windows. Puede aprovechar este hecho, así que digamos que está accediendo a una variable llamada bleh, simplemente use el operador invertido doble (!!)

!!window[''bleh''];

Esto devolvería un valor falso mientras que bleh no se ha declarado Y se le ha asignado un valor.

Answer 5

Creo que la forma más eficiente de probar "el valor es null o undefined " es

if ( some_variable == null ){
  // some_variable is either null or undefined
}

Así que estas dos líneas son equivalentes:

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Nota 1

Como se mencionó en la pregunta, la variante corta requiere que se haya declarado some_variable , de lo contrario se lanzará un ReferenceError. Sin embargo, en muchos casos de uso, puede suponer que esto es seguro:

verifique los argumentos opcionales:

function(foo){
    if( foo == null ) {...}

comprobar propiedades en un objeto existente

if(my_obj.foo == null) {...}

Por otro lado, typeof puede lidiar con variables globales no declaradas (simplemente devuelve undefined ). Sin embargo, estos casos deben reducirse al mínimo por buenas razones, como explicó Alsciende.

Nota 2

Esta variante, incluso más corta, no es equivalente:

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

asi que

if ( some_variable ) {
  // we don''t get here if some_variable is null, undefined, 0, NaN, false, or ""
}

Nota 3

En general, se recomienda utilizar === lugar de == . La solución propuesta es una excepción a esta regla. El verificador de sintaxis JSHint incluso proporciona la opción eqnull por este motivo.

De la guía de estilo jQuery :

Se deben utilizar controles de igualdad estrictos (===) a favor de ==. La única excepción es cuando se comprueba si está indefinido y nulo como nulo.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Answer 6

Debes definir una función de este formulario:

validate = function(some_variable){
    return(typeof(some_variable) != ''undefined'' && some_variable != null)
}

Answer 7

En los nuevos estándares de JavaScript como ES5 y ES6, simplemente puede decir

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

todos devuelven false, que es similar a la comprobación de Python de variables vacías. Entonces, si quieres escribir lógica condicional alrededor de una variable, solo di

if (Boolean(myvar)){
   // Do something
}

aquí "null" o "cadena vacía" o "indefinido" se manejarán de manera eficiente.

Answer 8

En primer lugar, debe ser muy claro acerca de lo que prueba. JavaScript tiene todo tipo de conversiones implícitas para hacerte tropezar, y dos tipos diferentes de comparador de igualdad: == y === .

Una función, test(val) que prueba null o undefined debe tener las siguientes características:

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test(''s'')          => false
 test([])           => false

Veamos cuál de las ideas aquí realmente pasa nuestra prueba.

Estos trabajos:

val == null
val === null || val === undefined
typeof(val) == ''undefined'' || val == null
typeof(val) === ''undefined'' || val === null

Estos no funcionan:

typeof(val) === ''undefined''
!!val

Creé una entrada jsperf para comparar la corrección y el rendimiento de estos enfoques. Los resultados no son concluyentes por el momento, ya que no ha habido suficientes ejecuciones en diferentes navegadores / plataformas. ¡Tómese un minuto para ejecutar la prueba en su computadora!

En la actualidad, parece que el simple val == null prueba val == null da el mejor rendimiento. También es más o menos el más corto. La prueba se puede negar a val != null si desea el complemento.

Answer 9

La comprobación de nulo con igualdad normal también devolverá true para undefined.

if (window.variable == null) alert(''variable is null or undefined'');

Answer 10

La prueba de nulidad ( if (value == null) ) o no nulidad ( if (value != null) ) es menos detallada que la prueba del estado de definición de una variable.

Además, probar if (value) (o if( obj.property) ) para asegurar la existencia de su variable (o propiedad de objeto) falla si se define con un valor false booleano. Caveat emptor :)

Answer 11

Para comprender, analicemos cuál será el valor devuelto por el motor de Javascript al convertir undefined, null y '''' (también una cadena vacía). Puedes verificar directamente lo mismo en tu consola de desarrollador.

Puedes ver que todos se están convirtiendo a falso, significa que estos tres están asumiendo "falta de existencia" por javascript. Por lo tanto, no necesita verificar explícitamente los tres en su código como se muestra a continuación.

if (a === undefined || a === null || a==='''') {
    console.log("Nothing");
} else {
    console.log("Something");
}

También quiero señalar una cosa más.

¿Cuál será el resultado de Boolean (0)?

Por supuesto falso. Esto creará algunos errores en su código cuando 0 se convierta en un valor válido en su resultado esperado. Así que por favor asegúrate de esto también cuando escribas el código

Answer 12

Puedes verificar si la variable tiene un valor o no. Sentido,

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

Si no sabe si existe una variable (es decir, si fue declarada), debe verificar con el operador typeof. p.ej

if( typeof myVariable !== ''undefined'' ) {
    // myVariable will get resolved and it is defined
}

Answer 13

Si intenta y hace referencia a una variable no declarada, se lanzará un error en todas las implementaciones de JavaScript.

Las propiedades de los objetos no están sujetas a las mismas condiciones. Si no se ha definido una propiedad de objeto, no se generará un error si intenta acceder a ella. Así que en esta situación podrías acortar:

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

a

if (myObj.some_property != null)

Con esto en mente, y el hecho de que las variables globales son accesibles como propiedades del objeto global ( window en el caso de un navegador), puede usar lo siguiente para las variables globales:

if (window.some_variable != null) {
    // Do something with some_variable
}

En los ámbitos locales, siempre es útil asegurarse de que las variables se declaren en la parte superior del bloque de código, esto ahorrará en los usos recurrentes de typeof .

Answer 14

Tienes que diferenciar entre dos casos:

1. Variables indefinidas, como foo . Obtendrá un error si accede a una variable no definida en cualquier contexto que no sea typeof .

   if(typeof someUndefVar == whatever) // works
   
   if(someUndefVar) // throws error  

   Por lo tanto, para las variables, la comprobación de typeof es una necesidad. Por otro lado, rara vez se necesita, por lo general, se sabe si sus variables están definidas o no.

2. Propiedades no someExistingObj.someUndefProperty , como someExistingObj.someUndefProperty . Una propiedad no definida no produce un error y simplemente devuelve undefined , que, cuando se convierte en un valor booleano, se evalúa como false . Por lo tanto, si no te importa el 0 y el false , usar if(obj.undefProp) está bien. Hay un lenguaje común basado en este hecho:

   value = obj.prop || defaultValue

   lo que significa "si obj tiene la propiedad prop , asigne un value , de lo contrario asigne el valor predeterminado defautValue ".

   Algunas personas consideran este comportamiento confuso, argumentando que conduce a errores difíciles de encontrar y recomiendan usar el operador in lugar

   value = (''prop'' in obj) ? obj.prop : defaultValue

Answer 15

cualquiera que sea yyy es indefinido o nulo, devolverá verdadero

if (typeof yyy == ''undefined'' || !yyy) {
    console.log(''yes'');
} else {
    console.log(''no'');
}

sí

if (!(typeof yyy == ''undefined'' || !yyy)) {
    console.log(''yes'');
} else {
    console.log(''no'');
}

no