¿Cómo verifico los valores nulos en JavaScript?

¿Cómo puedo verificar los valores nulos en JavaScript? Escribí el código a continuación pero no funcionó.

if (pass == null || cpass == null || email == null || cemail == null || user == null) {      

    alert("fill all columns");
    return false;  

}   

¿Y cómo puedo encontrar errores en mis programas de JavaScript?

Javascript es muy flexible con respecto a la comprobación de valores "nulos". Supongo que en realidad estás buscando cadenas vacías, en cuyo caso este código más simple funcionará:

if(!pass || !cpass || !email || !cemail || !user){

Que comprobará para cadenas vacías ( ""), null, undefined, falsey los números 0yNaN

Tenga en cuenta que si está verificando específicamente los números, es un error común omitir 0con este método, y num !== 0se prefiere ( num !== -1o ~num(código hacky que también verifica -1)) las funciones que devuelven -1, por ejemplo indexOf)

Para verificar nulo ESPECÍFICAMENTE , usaría esto:

if (variable === null)

Esta prueba sólo pasar por nully no pasará por "", undefined, false, 0, o NaN.

Además, he proporcionado verificaciones absolutas para cada valor "falso" (uno que devolvería verdadero para !variable).

Tenga en cuenta que, para algunas de las comprobaciones absolutas, deberá implementar el uso de absolutely equals: ===y typeof.

He creado un JSFiddle aquí para mostrar todas las pruebas individuales funcionando

Aquí está el resultado de cada verificación:

Null Test:

if (variable === null)

- variable = ""; (false) typeof variable = string

- variable = null; (true) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Empty String Test:

if (variable === '')

- variable = ''; (true) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number




Undefined Test:

if (typeof variable == "undefined")

-- or --

if (variable === undefined)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (true) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



False Test:

if (variable === false)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (true) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Zero Test:

if (variable === 0)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (true) typeof variable = number

- variable = NaN; (false) typeof variable = number



NaN Test:

if (typeof variable == 'number' && !parseFloat(variable) && variable !== 0)

-- or --

if (isNaN(variable))

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (true) typeof variable = number

Como puede ver, es un poco más difícil de probar NaN;

simplemente reemplace ==con ===en todos los lugares.

== es una comparación de igualdad suelta o abstracta

=== es una estricta comparación de igualdad

Consulte el artículo de MDN sobre las comparaciones de igualdad y la igualdad para obtener más detalles.

Operador de igualdad estricto: -

Podemos verificar nulo por ===

if ( value === null ){

}

Solo usando if

if( value ) {

}

se evaluará como verdadero si el valor no es :

• nulo
• indefinido
• Yaya
• cuerda vacía ("")
• falso
• 0 0

Mejora sobre la respuesta aceptada al verificar explícitamente nullpero con una sintaxis simplificada:

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
}

// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
    console.log ("Yayy! None of them are null");
} else {
    console.log ("Oops! At-lease one of them is null");
}

En primer lugar, tiene una declaración return sin un cuerpo de función. Lo más probable es que arroje un error.

¡Una forma más limpia de hacer su verificación sería simplemente usar el! operador:

if (!pass || !cpass || !email || !cemail || !user) {

    alert("fill all columns");

}

puedes usar try catch finalmente

 try {
     document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
 } catch (e) {

     if (e.name.toString() == "TypeError") //evals to true in this case
     //do something

 } finally {}   

También puedes throwtus propios errores. Mira esto .

En JavaScript, ninguna cadena es igual a null.

Tal vez esperaba pass == nullque fuera cierto cuando se passtrata de una cadena vacía porque sabe que el operador de igualdad suelta ==realiza ciertos tipos de coerción de tipo.

Por ejemplo, esta expresión es verdadera:

'' == 0

Por el contrario, el operador de igualdad estricta ===dice que esto es falso:

'' === 0

Teniendo en cuenta eso ''y 0son más o menos iguales, podrías conjeturar razonablemente eso ''y nullson más o menos iguales. Sin embargo, no lo son.

Esta expresión es falsa:

'' == null

El resultado de comparar cualquier cadena con nulles falso. Por lo tanto, pass == nully todas sus otras pruebas son siempre falsas, y el usuario nunca recibe la alerta.

Para arreglar su código, compare cada valor con la cadena vacía:

pass === ''

Si está seguro de que passes una cadena, pass == ''también funcionará porque solo una cadena vacía es más o menos igual a la cadena vacía. Por otro lado, algunos expertos dicen que es una buena práctica usar siempre la igualdad estricta en JavaScript a menos que específicamente desee hacer la coerción de tipo que realiza el operador de igualdad suelta.

Si desea saber qué pares de valores son aproximadamente iguales, consulte la tabla "Comparaciones de igualdad" en el artículo de Mozilla sobre este tema .

para verificar si está indefinido y nulo en javascript solo necesita escribir lo siguiente:

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}

Este es un comentario sobre la solución de WebWanderer con respecto a la verificación de NaN (todavía no tengo suficiente representante para dejar un comentario formal). La solución se lee como

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

pero esto fallará para números racionales que se redondearían a 0, como variable = 0.1. Una mejor prueba sería:

if(isNaN(variable) && typeof variable === "number")

En realidad, creo que puede necesitar usarlo if (value !== null || value !== undefined) porque si lo usa if (value)también puede filtrar 0 o valores falsos.

Considere estas dos funciones:

const firstTest = value => {
    if (value) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}
const secondTest = value => {
    if (value !== null && value !== undefined) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}

firstTest(0);            // result: failed
secondTest(0);           // result: passed

firstTest(false);        // result: failed
secondTest(false);       // result: passed

firstTest('');           // result: failed
secondTest('');          // result: passed

firstTest(null);         // result: failed
secondTest(null);        // result: failed

firstTest(undefined);    // result: failed
secondTest(undefined);   // result: failed

En mi situación, sólo necesitaba para comprobar si el valor es nulo e indefinido y que no quería para filtrar 0o falseo ''valores. así que usé la segunda prueba, pero es posible que también necesites filtrarlos, lo que puede hacer que uses la primera prueba.

Encontré otra forma de probar si el valor es nulo:

if(variable >= 0 && typeof variable === "object")

nullactúa como numbery object, al mismo tiempo. Comparación null >= 0o null <= 0resultados en true. Comparando null === 0o null > 0o null < 0dará lugar a falsas. Pero como nulltambién es un objeto, podemos detectarlo como nulo.

Hice una función más compleja, la naturaleza de la bruja funcionará mejor que el tipo y se me puede decir qué tipos incluir o mantener agrupados

/* function natureof(variable, [included types])
included types are 
    null - null will result in "undefined" or if included, will result in "null"
    NaN - NaN will result in "undefined" or if included, will result in "NaN"
    -infinity - will separate negative -Inifity from "Infinity"
    number - will split number into "int" or "double"
    array - will separate "array" from "object"
    empty - empty "string" will result in "empty" or
    empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/            if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/             if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" : 
/*-infinity*/       (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" : 
/*number*/          (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/           if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/           if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" : 
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
                    else return typeof v
}

// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]

for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined")) 
}

Hice esta función muy simple que hace maravillas:

function safeOrZero(route) {
  try {
    Function(`return (${route})`)();
  } catch (error) {
    return 0;
  }
  return Function(`return (${route})`)();
}

La ruta es cualquier cadena de valores que pueda explotar. Lo uso para jQuery / cheerio y objetos y tal.

Ejemplos 1: un objeto simple como este const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

Pero podría ser un objeto muy grande que ni siquiera hemos hecho. Entonces lo paso por:

let value1 = testobj.items[2].val;  // "hum!"
let value2 = testobj.items[3].val;  // Uncaught TypeError: Cannot read property 'val' of undefined

let svalue1 = safeOrZero(`testobj.items[2].val`)  // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`)  // 0

Por supuesto, si lo prefiere, puede usar nullo 'No value'... lo que se adapte a sus necesidades.

Por lo general, una consulta DOM o un selector jQuery puede arrojar un error si no se encuentra. Pero usando algo como:

const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
  [...]
}

Puede usar el módulo lodash para verificar que el valor sea nulo o indefinido

_.isNil(value)
Example 

 country= "Abc"
    _.isNil(country)
    //false

   state= null
    _.isNil(state)
    //true

city= undefined
    _.isNil(state)
    //true

   pin= true
    _.isNil(pin)
    // false   

Enlace de referencia: https://lodash.com/docs/#isNil

Esto no funcionará en caso de que los valores booleanos provengan de DB para ex:

 value = false

 if(!value) {
   // it will change all false values to not available
   return "not available"
 }

AFAIK en JAVASCRIPT cuando una variable se declara pero no tiene un valor asignado, su tipo es undefined. para que podamos verificar la variable incluso si se tratara de objectmantener alguna instancia en lugar de valor .

cree un método auxiliar para verificar la nulidad que devuelve truey úselo en su API.

función auxiliar para verificar si la variable está vacía:

function isEmpty(item){
    if(item){
        return false;
    }else{
        return true;
    }
}

llamada de API excepcional try-catch:

try {

    var pass, cpass, email, cemail, user; // only declared but contains nothing.

    // parametrs checking
    if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
        console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
    }else{
        // do stuff
    }

} catch (e) {
    if (e instanceof ReferenceError) {
        console.log(e.message); // debugging purpose
        return true;
    } else {
        console.log(e.message); // debugging purpose
        return true;
    }
}

algunos casos de prueba:

var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true

console.log("isEmpty? "+isEmpty(item));

Comprobación de condiciones de error:

// Typical API response data
let data = {
  status: true,
  user: [],
  total: 0,
  activity: {sports: 1}
}

// A flag that checks whether all conditions were met or not
var passed = true;

// Boolean check
if (data['status'] === undefined || data['status'] == false){
  console.log("Undefined / no `status` data");
  passed = false;
}

// Array/dict check
if (data['user'] === undefined || !data['user'].length){
  console.log("Undefined / no `user` data");
  passed = false;
}

// Checking a key in a dictionary
if (data['activity'] === undefined || data['activity']['time'] === undefined){
   console.log("Undefined / no `time` data");
   passed = false;
}

// Other values check
if (data['total'] === undefined || !data['total']){
  console.log("Undefined / no `total` data");
  passed = false;
}

// Passed all tests?
if (passed){
  console.log("Passed all tests");
}

Prueba esto:

if (!variable && typeof variable === "object") {
    // variable is null
}