Come posso determinare se una variabile è 'indefinita' o 'nulla'?

Come posso determinare se la variabile è undefinedo null?

Il mio codice è il seguente:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Ma se lo faccio, l'interprete JavaScript interrompe l'esecuzione.

È possibile utilizzare le qualità dell'operatore di uguaglianza astratta per fare ciò:

if (variable == null){
    // your code here.
}

Perché null == undefinedè vero, il codice sopra prenderà sia nulle undefined.

Il modo standard per catturare nulle undefinedcontemporaneamente è questo:

if (variable == null) {
     // do something 
}

- che equivale al 100% al più esplicito ma meno conciso:

if (variable === undefined || variable === null) {
     // do something 
}

Quando si scrive JS professionale, si dà per scontato che il tipo di uguaglianza e il comportamento di ==vs=== siano compresi. Pertanto usiamo ==e confrontiamo solo con null.

Modifica di nuovo

I commenti che suggeriscono l'uso di typeofsono semplicemente sbagliati. Sì, la mia soluzione sopra causerà un ReferenceError se la variabile non esiste. Questa è una buona cosa. Questo errore di riferimento è desiderabile: ti aiuterà a trovare i tuoi errori e risolverli prima di spedire il tuo codice, proprio come farebbero gli errori del compilatore in altre lingue. Usa try/ catchse stai lavorando con input su cui non hai il controllo.

Non dovresti avere riferimenti a variabili non dichiarate nel tuo codice.

Combinando le risposte di cui sopra, sembra che la risposta più completa sarebbe:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Questo dovrebbe funzionare per qualsiasi variabile non dichiarata o dichiarata e impostata esplicitamente su null o indefinita. L'espressione booleana deve essere valutata come falsa per qualsiasi variabile dichiarata che ha un valore effettivo non nullo.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

valuterà vero se il valore non è:

• nullo

• non definito

• NaN

• stringa vuota ("")

• 0

• falso

La attr()funzione jQuery restituisce una stringa vuota o il valore effettivo (e mai nullo undefined). L'unica volta che ritorna undefinedè quando il selettore non ha restituito alcun elemento.

Quindi potresti voler provare contro una stringa vuota. In alternativa, poiché le stringhe vuote, null e undefined sono false-y, puoi semplicemente fare questo:

if (!EmpName) { //do something }

Sono venuto a scrivere la mia funzione per questo. JavaScript è strano.

È utilizzabile su qualsiasi cosa. (Si noti che questo controlla anche se la variabile contiene valori utilizzabili . Ma poiché queste informazioni sono di solito necessarie, penso che valga la pena pubblicare). Ti preghiamo di considerare di lasciare una nota.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Dattiloscritto-compatibili.

Questa funzione dovrebbe fare esattamente la stessa cosa della empty()funzione di PHP (vedi RETURN VALUES)

Ritiene undefined, null, false, 0, 0.0, "0" {}, []come svuotare.

"0.0", NaN, " ", trueSono considerati non vuota.

Se la variabile che vuoi controllare è globale, fallo

if (window.yourVarName) {
    // Your code here
}

Questo modo di verificare non genererà un errore anche se la yourVarNamevariabile non esiste.

Esempio: voglio sapere se il mio browser supporta l'API Cronologia

if (window.history) {
    history.back();
}

Come funziona:

windowè un oggetto che contiene tutte le variabili globali come sue proprietà e in JavaScript è legale tentare di accedere a una proprietà dell'oggetto non esistente. Se historynon esiste, window.historyritorna undefined. undefinedè falso, quindi il codice in un if(undefined){}blocco non verrà eseguito.

Il più breve e semplice:

if(!EmpName ){
 // DO SOMETHING
}

questo valuterà vero se EmpName è:

• nullo
• non definito
• NaN
• vuoto
• corda ("")
• 0
• falso

Probabilmente il modo più breve per farlo è:

if(EmpName == null) { /* DO SOMETHING */ };

Ecco la prova:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

E qui ci sono maggiori dettagli su ==(fonte qui )

BONUS : motivo per cui ===è più chiaro di ==(guarda la risposta agc )

Ho appena avuto questo problema, ovvero verificare se un oggetto è nullo.
Lo uso semplicemente:

if (object) {
    // Your code
}

Per esempio:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

Dato che stai usando jQuery , puoi determinare se una variabile non è definita o il suo valore è nullo usando una singola funzione.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

jQuery check element non null:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

In JavaScript, per quanto ne so, possiamo controllare una variabile indefinita, nulla o vuota come di seguito.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Controlla tutte le condizioni:

if(variable === undefined || variable === null || variable === ''){
}

Puoi semplicemente usare quanto segue (so che ci sono modi più brevi per farlo, ma questo potrebbe rendere più facile l'osservazione visiva, almeno per gli altri che guardano il codice).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

Il modo più semplice per verificare è:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

Con la soluzione di seguito:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Sono in grado di verificare quanto segue:

• nullo
• non definito
• NaN
• vuoto
• corda ("")
• 0
• falso

Per verificare se una variabile è nulla o non definita, utilizzo il codice seguente.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Eseguo questo test nella console di Chrome. Usando (void 0) puoi controllare undefined:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Diamo un'occhiata a questo,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   In quanto sopra, la variabile è dichiarata solo come apple. In questo caso, se chiamiamo metodo alertverrà visualizzato indefinito.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

Nel secondo viene visualizzato null, poiché la variabile di applevalore è null.

Quindi puoi verificare se un valore è indefinito o nullo.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

Miglior modo:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Perché === controlla sia il tipo che il valore. Il tipo di entrambi è diverso ma il valore è lo stesso.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

Il foo == nullcontrollo dovrebbe fare il trucco e risolvere il caso "non definito OR null" nel modo più breve. (Non considerando il caso "foo non dichiarato"). Ma le persone che sono abituate ad avere 3 uguali (come la migliore pratica) potrebbero non accettarlo. Guarda le regole di eqeqeq o triple- egals in eslint e tslint ...

L'approccio esplicito, quando stiamo verificando se una variabile è undefinedo nullseparatamente, dovrebbe essere applicato in questo caso, e il mio contributo all'argomento (27 risposte non negative per ora!) È di usare void 0sia un modo breve che sicuro per eseguire il controllo per undefined.

L'uso foo === undefinednon è sicuro perché non definito non è una parola riservata e può essere ombreggiato ( MDN ). L'uso di typeof === 'undefined'check è sicuro, ma se non ci occuperemo del caso foo-is -larlared è possibile utilizzare il seguente approccio:

if (foo === void 0 || foo === null) { ... }

se si crea una funzione per verificarla:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

La chiamata di typeof null restituisce un valore di "oggetto", poiché il valore speciale null viene considerato come riferimento a un oggetto vuoto. Safari fino alla versione 5 e Chrome fino alla versione 7 hanno una stranezza in cui la chiamata di typeof su un'espressione regolare restituisce "funzione" mentre tutti gli altri browser restituiscono "oggetto".

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Puoi usare solo il secondo: poiché controllerà sia la definizione che la dichiarazione

Penso ancora che il modo migliore / sicuro per testare queste due condizioni sia quello di trasmettere il valore a una stringa:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Puoi verificare se il valore è indefinito o nullo semplicemente usando typeof:

if(typeof value == 'undefined'){

if(x==null)è una cattiva idea in JavaScript. Giudicare con "=="- può causare una coercizione di tipo imprevista e non può essere letto da CoffeeScript, non usare mai "==" o "! =" Nel giudizio di condizione!

if(x)andrà meglio, ma fai attenzione con 0 e "" . Sarà trattata come falsa , non il metodo di parità con "!= null"è vero .

Vedi le best practice di JavaScript .