Come posso verificare i valori null in JavaScript?


576

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?


Sei sicuro che i valori che stai testando siano effettivamente nulli e non solo stringhe vuote?
Jan-Peter Vos,

72
i test nullin js dovrebbero essere fatti con l'operatore rigoroso===
davin

3
@davin: vero, ma non il problema qui, poiché se fosse la dichiarazione funzionerebbe comunque.
Mark Kahn,

3
@cwolves, se avessi pensato che fosse il problema avrei fatto una risposta a quel commento. Dai un'occhiata alla mia formulazione, sto chiaramente facendo una dichiarazione generale sulla lingua in riferimento alla pratica del PO, e non sto proponendo che questo risolva il suo problema.
davin

2
@TRiG le modifiche proposte alterano sostanzialmente la natura della domanda al punto in cui le risposte (non solo le mie) perdono il contesto e non hanno senso. La modifica dovrebbe essere solo un commento.
ic3b3rg,

Risposte:


743

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)


4
Sarebbe molto utile sapere quali parti di questo test per quali valori. A volte ne stai cercando uno in particolare.
Inorganik,

2
In qualche modo una dichiarazione tardiva, ma sì, è possibile eseguire test su ciascuno @inorganik, vedere la mia risposta di seguito
WebWanderer,

28
Lettori, fate attenzione quando utilizzate questo tipo di test su dati numerici. Non utilizzare !o !!per testare nullo undefinedsu dati tipicamente numerici a meno che non si desideri eliminare anche valori di 0.
NickS

4
La risposta stessa afferma questo: "... e i numeri 0...". Credo che questa risposta sia perfettamente appropriata per la domanda dato il contesto (che sto deducendo è "nome utente, password, e-mail"), non stanno verificando i 0valori. Data la popolarità di questa domanda e risposta, tuttavia, sono d'accordo che vale la pena menzionare nella risposta stessa.
Mark Kahn,

4
@Hendeca - rotola gli occhi Vai a leggere il codice nella domanda reale. E ' chiaramente chiedendo di nomi utente e password. Non sto indovinando nulla, ero solo educato. Sei infastidito dal fatto che ho risposto a ciò di cui avevano bisogno e non a quello che chiedevano, il che è assurdo. Questo è così, il più delle volte le persone non sanno cosa dovrebbero chiedere. Nel contesto della domanda originale questa risposta è corretta. Ora smetti di aggiungere rumore.
Mark Kahn,

420

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;


9
Qual è lo scopo del controllo del tipo se si utilizza ===l'uguaglianza rigorosa? Grazie. Anche per il test NaN è possibile utilizzare isNaN(value)che restituirà truesolo se la variabile è uguale a NaN.
Michael Malinovskij,

16
C'è un caso in cui, variable === nullma non è di tipo "oggetto"? In caso contrario, perché non semplificare il controllo variable === null, eliminando il secondo congiunto? Grazie.
Hunan Rostomyan,

7
@HunanRostomyan Bella domanda, e onestamente, no, non credo che ci sia. Molto probabilmente sei abbastanza sicuro usando quello variable === nullche ho appena testato qui in questo JSFiddle . Il motivo per cui ho anche usato `&& typeof variabile === 'oggetto' 'non era solo per illustrare il fatto interessante che un nullvalore è un tipo di object, ma anche per mantenere il flusso degli altri controlli. Ma sì, in conclusione, sei sicuro da usare semplicemente variable === null.
WebWanderer,

1
jsfiddle.net/neoaptt/avt1cgem/1 Ecco questa risposta suddivisa in funzioni. Non molto utile, ma l'ho fatto comunque.
Neoaptt,

1
Farò qualcosa che non è quasi mai una buona idea: cambiare il codice in questa risposta. In particolare, rimuovere il test totalmente inutile per l'oggetto tipo, quando si verifica la presenza di null. Questo è uno snippet di codice fondamentale : non è una buona idea avere anche un solo principiante che impari male che devono fare quel test dettagliato.
ToolmakerSteve

59

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.


2
Funziona solo se si considera undefinedche non lo è null. Altrimenti porterà a molti comportamenti inaspettati. Generalmente se sei interessato a entrambi null/ undefinedma non a valori falsi, usa ==(uno dei pochi casi in cui dovresti farlo).
Andrew Mao,

2
@AndrewMao undefined non è null : stackoverflow.com/a/5076962/753237
ic3b3rg

2
Credo sia quello che stava dicendo @AndrewMao, davvero. La sua prima frase potrebbe essere riscritta "Funziona solo in situazioni in cui indefinito e nullo non sono equivalenti pratici".
BobRodes

1
@BobRodes Grazie per aver chiarito la mia scarsa scrittura, lo apprezzo :)
Andrew Mao,

@AndrewMao Sei il benvenuto. E non definirei la tua scrittura povera, personalmente; Direi che è molto meglio della media. :)
BobRodes

30

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

9

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


6

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

}

12
Quel codice è probabilmente in una funzione, semplicemente non l'ha mostrato;)
Mark Kahn

4

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 .


1
penso che questo si qualifichi come codice "paranoico". se davvero scrivessi qualcosa del genere, capiresti che "mydiv" non potrebbe non esistere. non dovremmo raggiungere questo codice a meno che non siamo sicuri che sia il caso, e avremmo un sacco di strade come i codici di risposta per assicurarci di essere sicuri prima di tentare una simile linea.
calql8edkos,

Non utilizzare try and catch per il flusso di controllo. Questa non è una buona soluzione.
Andrew S

4

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 .


4

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

6
! var è vero anche con 0, "", NaN e falso.
Matt,

3

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

1
Grazie per aver segnalato il bug Gabriel, ho inserito la soluzione nella mia risposta. A parte questo, sono stato in grado di risolvere il test cambiando parseIntin parseFloat (che per me avrebbe dovuto essere ovvio in primo luogo). Ho evitato di usare la isNanfunzione perché mi sento come se molti sviluppatori vedessero funzioni isNaNcome una sorta di "scatola magica" in cui vanno i valori e dai booleani, e volevo che il test fosse un po 'più approfondito. Ma sì, il test suggerito funzionerà ed è perfettamente bene da usare. Mi dispiace non aver notato il tuo post fino ad ora.
WebWanderer,

1
Fantastico, sembra funzionare. Grazie per il commento sul perché hai evitato isNaNanche io, posso andare dietro quella logica. C'è anche il metodo Underscore.js, che sembra ancora più confuso / blackbox, ma vale la pena notare comunque perché ne approfitta NaN !== NaN. Object.prototype.toString.call(variable) === '[object Number]' && variable !== +variable
Gabriel,

2

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.


1

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


1

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){
  [...]
}

1

È 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


0

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

0

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

1
Che cosa? Questa risposta non ha nulla a che fare con questo post. Hai pubblicato questa risposta su questa discussione per caso?
WebWanderer,

Questa isEmptyfunzione si comporta esattamente come !. Non è necessario inventare una funzione. Fallo e basta if (!pass || !cpass || !email ...). (Che è già mostrato nella risposta accettata.) E per il commento di WebWanderer, la parte centrale di questo post, "prova a intercettare una chiamata API eccezionale", non sembra essere rilevante per questa domanda. Spiega il tuo intento: quando è utile? In che modo ciò si collega alla domanda?
ToolmakerSteve

0

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

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.