Come posso verificare i valori null in JavaScript?

Come posso verificare i valori null in JavaScript? Ho scritto il codice qui sotto ma non ha funzionato.

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

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

}   

E come posso trovare errori nei miei programmi JavaScript?

Javascript è molto flessibile per quanto riguarda il controllo di valori "null". Immagino che tu stia effettivamente cercando stringhe vuote, nel qual caso funzionerà questo codice più semplice:

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

Quale sarà verificare la presenza di stringhe vuote ( ""), null, undefined, falsee il numero 0eNaN

Si noti che se si sta verificando specificamente la presenza di numeri, è un errore comune mancare 0con questo metodo ed num !== 0è preferito (o num !== -1o ~num(codice hacky che verifica anche contro -1)) per le funzioni che restituiscono -1, ad es. indexOf)

Per verificare la nullità SPECIFICAMENTE , utilizzare questo:

if (variable === null)

Questo test sarà solo passare per nulle non passerà per "", undefined, false, 0, o NaN.

Inoltre, ho fornito controlli assoluti per ogni valore "falso-simile" (uno che restituirebbe true per !variable).

Nota, per alcuni dei controlli assoluti, dovrai implementare l'uso di absolutely equals: ===e typeof.

Ho creato un JSFiddle qui per mostrare tutti i singoli test funzionanti

Ecco l'output di ogni controllo:

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

Come puoi vedere, è un po 'più difficile provare NaN;

basta sostituire il ==con ===in tutti i posti.

== è un confronto di uguaglianza libero o astratto

=== è un rigoroso confronto sull'uguaglianza

Vedi l'articolo MDN sui confronti di uguaglianza e uguaglianza per maggiori dettagli.

Operatore di uguaglianza rigorosa: -

Possiamo controllare null da ===

if ( value === null ){

}

Solo usando if

if( value ) {

}

valuterà vero se il valore non è :

• nullo
• non definito
• NaN
• stringa vuota ("")
• falso
• 0

Miglioramento rispetto alla risposta accettata verificando esplicitamente nullma con una sintassi semplificata:

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

Innanzitutto, hai una dichiarazione di ritorno senza un corpo di funzione. È probabile che ciò provocherà un errore.

Un modo più pulito di fare il controllo sarebbe semplicemente usare il! operatore:

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

    alert("fill all columns");

}

puoi finalmente provare a catturare

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

puoi anche i throwtuoi errori. Vedere questo .

In JavaScript, nessuna stringa è uguale a null.

Forse ti aspettavi pass == nulldi essere vero quando passè una stringa vuota perché sei consapevole che l'operatore di uguaglianza libera ==esegue determinati tipi di coercizione di tipo.

Ad esempio, questa espressione è vera:

'' == 0

Al contrario, l'operatore di uguaglianza rigorosa ===afferma che questo è falso:

'' === 0

Dato che ''e 0sono vagamente uguali, potresti ragionevolmente congetturarlo ''e nullsono vagamente uguali. Tuttavia, non lo sono.

Questa espressione è falsa:

'' == null

Il risultato del confronto di qualsiasi stringa con nullè falso. Pertanto, pass == nulle tutti gli altri test sono sempre falsi e l'utente non riceve mai l'avviso.

Per correggere il codice, confronta ogni valore con la stringa vuota:

pass === ''

Se sei sicuro che passsia una stringa, pass == ''funzionerà anche perché solo una stringa vuota è vagamente uguale alla stringa vuota. D'altra parte, alcuni esperti affermano che è una buona pratica usare sempre la rigorosa uguaglianza in JavaScript a meno che non si desideri fare specificamente la coercizione del tipo eseguita dall'operatore di uguaglianza libera.

Se vuoi sapere quali coppie di valori sono vagamente uguali, consulta la tabella "Confronti di identità" nell'articolo di Mozilla su questo argomento .

per verificare la presenza di undefined e null in javascript devi solo scrivere quanto segue:

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

Questo è un commento sulla soluzione di WebWanderer riguardante il controllo di NaN (non ho ancora abbastanza rappresentante per lasciare un commento formale). La soluzione dice come

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

ma questo fallirà per i numeri razionali che dovrebbero arrotondare 0, come ad esempio variable = 0.1. Un test migliore sarebbe:

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

In realtà penso che potrebbe essere necessario utilizzare if (value !== null || value !== undefined) perché se si utilizza if (value)è anche possibile filtrare 0 o valori falsi.

Considera queste due funzioni:

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

Nella mia situazione, dovevo solo verificare se il valore è nullo e indefinito e non volevo filtrare 0o falseo ''valori. quindi ho usato il secondo test, ma potresti aver bisogno di filtrare anche loro, il che potrebbe farti usare il primo test.

Ho trovato un altro modo per verificare se il valore è null:

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

nullfunge da numbere objectallo stesso tempo. Confronto null >= 0o null <= 0risultati in true. Il confronto null === 0o null > 0o null < 0comporterà falso. Ma poiché nullè anche un oggetto, possiamo rilevarlo come null.

Ho fatto una funzione più complessa della natura che la strega farà meglio del tipo e posso dire quali tipi includere o tenere raggruppati

/* 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")) 
}

Ho realizzato questa funzione molto semplice che fa miracoli:

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

Il percorso è qualunque catena di valori che può esplodere. Lo uso per jQuery / cheerio e oggetti e simili.

Esempi 1: un oggetto semplice come questo const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

Ma potrebbe essere un oggetto molto grande che non abbiamo nemmeno realizzato. Quindi lo passo attraverso:

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

Naturalmente, se preferisci, puoi usare nullo 'No value'... Qualunque sia la tua esigenza.

Di solito una query DOM o un selettore jQuery possono generare un errore se non viene trovato. Ma usando qualcosa come:

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

È possibile utilizzare il modulo lodash per verificare che il valore sia nullo o non definito

_.isNil(value)
Example 

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

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

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

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

Link di riferimento: https://lodash.com/docs/#isNil

Questo non funzionerà in caso di valori booleani provenienti da DB per es:

 value = false

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

AFAIK in JAVASCRIPT quando viene dichiarata una variabile ma non è stato assegnato alcun valore, il suo tipo è undefined. così possiamo controllare la variabile anche se si tratterebbe di objectmantenere qualche istanza al posto del valore .

crea un metodo di supporto per verificare la nullità che ritorna truee usalo nella tua API.

funzione helper per verificare se la variabile è vuota:

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

prova-cattura chiamata API eccezionale:

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

alcuni casi di test:

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

Verifica delle condizioni di errore:

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

Prova questo:

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