Comprobación nula de JavaScript

Me he encontrado con el siguiente código:

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

Soy algo nuevo en JavaScript, pero, por otras preguntas que he estado leyendo aquí, tengo la impresión de que este código no tiene mucho sentido.

Obtendrá un error si accede a una variable indefinida en cualquier contexto que no sea typeof.

Actualización: la (cita de) la respuesta anterior puede ser engañosa. Debería decir "una variable no declarada" , en lugar de "una variable indefinida" .

Como descubrí, en las respuestas de Ryan ♦ , maerics y nwellnhof , incluso cuando no se proporcionan argumentos para una función, sus variables para los argumentos siempre se declaran. Este hecho también demuestra que es incorrecto el primer elemento de la lista a continuación.

Según tengo entendido, se pueden experimentar los siguientes escenarios:

• Se llamó a la función sin argumentos, por lo que se datacreó una variable indefinida y se generó un error data != null.

• La función se llamó específicamente con null(o undefined), como argumento, en cuyo caso data != nullya protege el código interno, && data !== undefinedinutilizándolo.

• La función se llamó con un argumento no nulo, en cuyo caso pasará trivialmente ambos data != null y data !== undefined .

P: ¿Es correcto mi entendimiento?

He intentado lo siguiente, en la consola de Firefox:

--
[15:31:31.057] false != null
[15:31:31.061] true
--
[15:31:37.985] false !== undefined
[15:31:37.989] true
--
[15:32:59.934] null != null
[15:32:59.937] false
--
[15:33:05.221] undefined != null
[15:33:05.225] false
--
[15:35:12.231] "" != null
[15:35:12.235] true
--
[15:35:19.214] "" !== undefined
[15:35:19.218] true

No puedo entender un caso en el que el data !== undefined after data != null pueda ser de alguna utilidad.

Una "variable indefinida" es diferente del valor undefined.

Una variable indefinida:

var a;
alert(b); // ReferenceError: b is not defined

Una variable con el valor undefined:

var a;
alert(a); // Alerts “undefined”

Cuando una función toma un argumento, ese argumento siempre se declara incluso si su valor es undefined, por lo que no habrá ningún error. Sin embargo, tienes razón en ser != nullseguido por !== undefinedser inútil.

En JavaScript, nulles un objeto singleton especial que es útil para señalar "sin valor". Puede probarlo en comparación y, como es habitual en JavaScript, es una buena práctica usar el ===operador para evitar la coerción de tipo confusa:

var a = null;
alert(a === null); // true

Como @rynah menciona, "indefinido" es un poco confuso en JavaScript. Sin embargo, siempre es seguro probar si la typeof(x)cadena es "indefinida", incluso si "x" no es una variable declarada:

alert(typeof(x) === 'undefined'); // true

Además, las variables pueden tener el "valor indefinido" si no se inicializan:

var y;
alert(typeof(y) === 'undefined'); // true

Poniendo todo junto, su cheque debería verse así:

if ((typeof(data) !== 'undefined') && (data !== null)) {
  // ...

Sin embargo, dado que la variable "datos" siempre se define ya que es un parámetro de función formal, no es necesario utilizar el operador "typeof" y puede compararlo directamente con el "valor indefinido".

function(data) {
  if ((data !== undefined) && (data !== null)) {
    // ...

Este fragmento equivale a decir "si la función fue llamada con un argumento que está definido y no es nulo ..."

En su caso, use data==null(lo cual es cierto SOLO para valores nulos e indefinidos; en la segunda imagen, enfoque en filas / columnas nulo-indefinido)

function test(data) {
    if (data != null) {
        console.log('Data: ', data);
    }
}

test();          // the data=undefined
test(null);      // the data=null
test(undefined); // the data=undefined

test(0); 
test(false); 
test('something');

Aquí tienes todo ( src ):

Si

== (su negación ! = )

=== (su negación ! == )

P: La función se invocó sin argumentos, lo que convierte los datos en una variable indefinida y genera un error en los datos! = Nulo.

A: Sí, datase establecerá en indefinido. Consulte la sección 10.5 Declaración de vinculación de instanciación de la especificación. Pero acceder a un valor indefinido no genera un error. Probablemente esté confundiendo esto con acceder a una variable no declarada en modo estricto que genera un error.

P: La función se llamó específicamente con nulo (o indefinido), como argumento, en cuyo caso data! = Null ya protege el código interno, lo que hace que && data! == indefinido sea inútil.

P: La función se llamó con un argumento no nulo, en cuyo caso pasará trivialmente data! = Null y data! == undefined.

A: correcto. Tenga en cuenta que las siguientes pruebas son equivalentes:

data != null
data != undefined
data !== null && data !== undefined

Consulte la sección 11.9.3 El algoritmo de comparación de igualdad abstracta y la sección 11.9.6 El Algoritmo de comparación de igualdad estricto de la especificación.

Creo que probar variables para valores que no esperas no es una buena idea en general. Porque la prueba como su puede considerar como escribir una lista negra de valores prohibidos. ¿Pero qué pasa si olvida enumerar todos los valores prohibidos? Alguien, incluso usted, puede descifrar su código al pasar un valor inesperado. Por lo tanto, un enfoque más apropiado es algo así como la lista blanca: probar variables solo para los valores esperados, no inesperados. Por ejemplo, si espera que el valor de los datos sea una cadena, en lugar de esto:

function (data) {
  if (data != null && data !== undefined) {
    // some code here
    // but what if data === false?
    // or data === '' - empty string?
  }
}

haz algo como esto:

function (data) {
  if (typeof data === 'string' && data.length) {
    // consume string here, it is here for sure
    // cleaner, it is obvious what type you expect
    // safer, less error prone due to implicit coercion
  } 
}

typeof foo === "undefined"es diferente de foo === undefined, nunca los confundas. typeof foo === "undefined"es lo que realmente necesitas. Además, use !==en lugar de!=

Entonces la declaración se puede escribir como

function (data) {
  if (typeof data !== "undefined" && data !== null) {
    // some code here
  }
}

Editar:

No se puede usar foo === undefinedpara variables no declaradas.

var t1;

if(typeof t1 === "undefined")
{
  alert("cp1");
}

if(t1 === undefined)
{
  alert("cp2");
}

if(typeof t2 === "undefined")
{
  alert("cp3");
}

if(t2 === undefined) // fails as t2 is never declared
{
  alert("cp4");
}

La forma simple de hacer tu prueba es:

function (data) {
    if (data) { // check if null, undefined, empty ...
        // some code here
    }
}

var a;
alert(a); //Value is undefined

var b = "Volvo"; 
alert(b); //Value is Volvo

var c = null;
alert(c); //Value is null