Come verificare una variabile non definita o nulla in JavaScript?

Question

Stiamo spesso utilizzando il seguente codice di modello nel nostro codice JavaScript

if (typeof(some_variable) != 'undefined' && some_variable != null) 
{ 
    // Do something with some_variable 
} 

C'è un modo meno prolissa di controllo che ha lo stesso effetto?

Secondo alcuni forum e la letteratura che dice semplicemente quanto segue dovrebbe avere lo stesso effetto.

if (some_variable) 
{ 
    // Do something with some_variable 
} 

Purtroppo, Firebug valuta una tale dichiarazione come errore runtime quando some_variable è indefinito, mentre il primo è bene per essa. Questo è solo un comportamento (indesiderato) di Firebug o c'è davvero qualche differenza tra questi due modi?

Answer 1

si deve distinguere tra due casi

1) Non definita variabili, come 'foo'. Riceverai un errore se accedi a una variabile non definita in un contesto diverso da typeof.

if(typeof someUndefVar == whatever) -- works 
    if(someUndefVar) -- error 

Quindi, per le variabili, il tipo di controllo è obbligatorio. D'altra parte, è solo raramente necessario - di solito lo conosce se le tue variabili sono definite o meno.

2) Non definito proprietà, come someExistingObj.someUndefProperty. Una proprietà non definita non produce un errore e restituisce semplicemente "indefinito", che, una volta convertito in booleano, restituisce un valore falso. Quindi, se non ti interessa di '0' e 'falso', if(obj.undefProp) è ok. C'è un linguaggio comune basato su questo fatto:

value = obj.prop || defaultValue 

che significa "se obj ha un puntello, l'uso che, altrimenti di default".

Alcune persone considerano questo comportamento confusione, sostenendo che porta a difficili da trovare gli errori e consiglia di utilizzare in operator invece

value = ('prop' in obj) ? obj.prop : defaultValue 

Answer 2

Se si tenta di fare riferimento a una variabile non dichiarata, verrà generato un errore in tutte le implementazioni di JavaScript.

Le proprietà degli oggetti non sono soggette alle stesse condizioni. Se una proprietà dell'oggetto non è stata definita, non verrà generato un errore se si tenta di accedervi. Quindi, in questa situazione si potrebbe accorciare:

if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null) 

a

if (myObj.some_property != null) 

Con questo in mente, e il fatto che le variabili globali sono accessibili come proprietà dell'oggetto globale (window nel caso di un browser), è possibile utilizzare il seguente per le variabili globali:

if (window.some_variable != null) { 
    // Do something with some_variable 
} 

negli ambiti locali, è sempre utile per rendere le variabili sicuri vengono dichiarate nella parte superiore del vostro codice blocco, questo salverà sugli usi ricorrenti di typeof.

Answer 3

Penso che il modo più efficace per verificare "il valore è null o undefined" è

if (some_variable == null){ 
    // some_variable is either null or undefined 
} 

Così queste due linee sono equivalenti:

if (typeof(some_variable) !== "undefined" && some_variable !== null) {} 
if (some_variable != null) {} 

Nota 1

Come indicato nella domanda, la breve variante richiede che some_variable è stata dichiarata, altrimenti un ReferenceError saranno gettati. Tuttavia, in molti casi d'uso si può supporre che questo è sicuro:

controllo per gli argomenti opzionali:

function(foo){ 
    if(foo == null) {...} 

di controllo per le proprietà su un oggetto esistente

if(my_obj.foo == null) {...} 

D'altra parte typeof può trattare con variabili globali non dichiarate (restituisce semplicemente undefined). Tuttavia questi casi dovrebbero essere ridotti al minimo per buone ragioni, come spiegato da Alsciende.

Nota 2

Questo - ancora più breve - variante è non equivalente:

if (!some_variable) { 
    // some_variable is either null, undefined, 0, NaN, false, or an empty string 
} 

così

if (some_variable) { 
    // we don't get here if some_variable is null, undefined, 0, NaN, false, or "" 
} 

Nota 3

In generale si consiglia di utilizzare === anziché ==. La soluzione proposta è un'eccezione a questa regola. Il JSHint syntax checker fornisce anche l'opzione eqnull per questo motivo.

Dal jQuery style guide:

Strict equality checks (===) should be used in favor of ==. The only exception is when checking for undefined and null by way of null.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null; 

Answer 4

Poiché non esiste una sola risposta completa e corretta, cercherò di riassumere:

In generale, l'espressione:

if (typeof(variable) != "undefined" && variable != null) 

non può essere semplificato, perché il variable potrebbe non essere dichiarato, quindi omettere lo typeof(variable) != "undefined" risulterebbe in ReferenceError.Ma, è possibile semplificare l'espressione a seconda del contesto:

Se il variable è globale, è possibile semplificare a:

if (window.variable != null) 

Se è locali, probabilmente si può evitare situazioni quando questa variabile è sommerso, e anche semplificare a:

if (variable != null) 

Se è proprietà dell'oggetto, non devi preoccuparti di ReferenceError:

if (obj.property != null) 

Answer 5

è necessario definire una funzione di questo modulo:

validate = function(some_variable){ 
    return(typeof(some_variable) != 'undefined' && some_variable != null) 
} 

Answer 6

primo luogo è necessario essere molto chiari su ciò che si prova. JavaScript ha tutti i tipi di conversioni implicite per farti saltare in aria e due diversi tipi di comparatori di uguaglianza: == e ===.

Una funzione, test(val) che i test per null o undefined dovrebbe avere le seguenti caratteristiche:

test(null)   => true 
test(undefined) => true 
test(0)   => false 
test(1)   => false 
test(true)   => false 
test(false)  => false 
test('s')   => false 
test([])   => false 

Vediamo quale delle idee qui in realtà superare la nostra prova.

Questi lavori:

val == null 
val === null || val === undefined 
typeof(val) == 'undefined' || val == null 
typeof(val) === 'undefined' || val === null 

Questi non funzionano:

typeof(val) === 'undefined' 
!!val 

ho creato un jsperf entry to compare the correctness and performance di questi approcci. I risultati non sono conclusivi per il momento in quanto non ci sono state corse sufficienti su diversi browser/piattaforme. Si prega di prendere un minuto per eseguire il test sul tuo computer!

Allo stato attuale, sembra che il semplice test val == null dia le migliori prestazioni. È anche il più corto. Il test può essere negato a val != null se si desidera il complemento.

Answer 7

Come menzionato in una delle risposte, si può essere fortunati se si parla di una variabile che ha una portata globale. Come forse saprai, le variabili che definisci globalmente tendono ad essere aggiunte all'oggetto Windows. È possibile usufruire di questo fatto in modo diciamo che si accede a un bleh variabile chiamata, basta usare l'operatore doppia invertito (!!)

!!window['bleh']; 

Questo sarebbe restituire un falso mentre bleh non è stato dichiarato e assegnato un valore di .

Answer 8

Il test di nullità (if (value == null)) o non nullità (if (value != null)) è meno dettagliato rispetto al test dello stato di definizione di una variabile.

Inoltre, il test if (value) (o if(obj.property)) per garantire l'esistenza della variabile (o un oggetto di proprietà) non riesce se è definito con un valore booleano false.Caveat emptor :)

Answer 9

Il controllo nullo con uguaglianza normale restituirà anche true per indefinito.

if (window.variable == null) alert('variable is null or undefined');

Answer 10

Entrambi i valori possono essere facilmente distinte utilizzando l'rigorosa operatore di confronto: ad esempio

Lavorare in:

http://www.thesstech.com/tryme?filename=nullandundefined

codice di esempio:

function compare(){ 
    var a = null; //variable assigned null value 
    var b; // undefined 
    if (a === b){ 
     document.write("a and b have same datatype."); 
    } 
    else{ 
     document.write("a and b have different datatype."); 
    } 
} 

Answer 11

In standard più recenti come JavaScript ES5 e ES6 si può solo dire

> Boolean(0) //false 
> Boolean(null) //false 
> Boolean(undefined) //false 

tutto return false, che è simile al controllo di Python di variabili vuote. Quindi, se si vuole scrivere la logica condizionale intorno una variabile, basta dire

if (Boolean(myvar)){ 
    // Do something 
} 

qui "null" o "stringa vuota" o "indefinito" sarà gestito in modo efficiente.

Answer 12

È possibile controllare se la variabile ha un valore o meno. Significato,

if(myVariable) { 
//mayVariable is not : 
//null 
//undefined 
//NaN 
//empty string ("") 
//0 
//false 

} 

Se non si sa se esiste una variabile (che significa, se è stato dichiarato) si dovrebbe verificare con l'operatore typeof. per esempio.

if(typeof myVariable !== 'undefined') { 
    // myVariable will get resolved and it is defined 
} 

Answer 13

qualunque yyy è undefined o null, esso ritornerà vero

if (typeof yyy == 'undefined' || !yyy) { 
    console.log('yes'); 
} else { 
    console.log('no'); 
} 

sì

if (!(typeof yyy == 'undefined' || !yyy)) { 
    console.log('yes'); 
} else { 
    console.log('no'); 
} 

senza

Answer 14

Aprire le Strumenti per sviluppatori nel browser e basta provare il codice mostrato nell'immagine qui sotto.