Controllo null JavaScript

Mi sono imbattuto nel seguente codice:

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

Sono un po 'nuovo di JavaScript, ma, da altre domande che ho letto qui, ho l'impressione che questo codice non abbia molto senso.

Riceverai un errore se accedi a una variabile non definita in qualsiasi contesto diverso da typeof.

Aggiornamento: la (citazione della) risposta sopra potrebbe essere fuorviante. Dovrebbe dire «una variabile non dichiarata» , invece di «una variabile non definita» .

Come ho scoperto, nelle risposte di Ryan ♦ , maerics e nwellnhof , anche quando non viene fornito alcun argomento a una funzione, le sue variabili per gli argomenti vengono sempre dichiarate. Questo fatto dimostra inoltre che il primo elemento nell'elenco seguente è errato.

Da quanto ho capito, si possono verificare i seguenti scenari:

• La funzione è stata chiamata senza argomenti, creando così datauna variabile non definita e generando un errore data != null.

• La funzione è stata chiamata specificamente con null(o undefined), come argomento, nel qual caso data != nullprotegge già il codice interno, rendendolo && data !== undefinedinutile.

• La funzione è stata chiamata con un argomento non nullo, nel qual caso passerà banalmente sia data != null e data !== undefined .

D: La mia comprensione è corretta?

Ho provato quanto segue, nella console di Firefox:

--
[15:31:31.057] false != null
[15:31:31.061] true
--
[15:31:37.985] false !== undefined
[15:31:37.989] true
--
[15:32:59.934] null != null
[15:32:59.937] false
--
[15:33:05.221] undefined != null
[15:33:05.225] false
--
[15:35:12.231] "" != null
[15:35:12.235] true
--
[15:35:19.214] "" !== undefined
[15:35:19.218] true

Non riesco a capire un caso in cui il data !== undefined dopo data != null potrebbe essere di qualche utilità.

Una "variabile non definita" è diversa dal valore undefined.

Una variabile non definita:

var a;
alert(b); // ReferenceError: b is not defined

Una variabile con il valore undefined:

var a;
alert(a); // Alerts “undefined”

Quando una funzione accetta un argomento, quell'argomento viene sempre dichiarato anche se il suo valore è undefined, e quindi non ci sarà alcun errore. Hai ragione, != nullseguito !== undefineddall'essere inutile, però.

In JavaScript, nullè un oggetto singleton speciale che è utile per segnalare "nessun valore". Puoi testarlo per confronto e, come al solito in JavaScript, è una buona pratica usare l' ===operatore per evitare confusione di tipo confuso:

var a = null;
alert(a === null); // true

Come menziona @rynah, "undefined" è un po 'confuso in JavaScript. Tuttavia, è sempre sicuro verificare se la typeof(x)stringa è "non definita", anche se "x" non è una variabile dichiarata:

alert(typeof(x) === 'undefined'); // true

Inoltre, le variabili possono avere il "valore indefinito" se non sono inizializzate:

var y;
alert(typeof(y) === 'undefined'); // true

Mettendo tutto insieme, il tuo controllo dovrebbe assomigliare a questo:

if ((typeof(data) !== 'undefined') && (data !== null)) {
  // ...

Tuttavia, poiché la variabile "dati" è sempre definita poiché si tratta di un parametro di funzione formale, l'utilizzo dell'operatore "typeof" non è necessario e si può tranquillamente confrontare direttamente con il "valore indefinito".

function(data) {
  if ((data !== undefined) && (data !== null)) {
    // ...

Questo frammento equivale a dire "se la funzione è stata chiamata con un argomento che è definito e non è nullo ..."

Nel tuo caso usa data==null(che è vero SOLO per null e indefinito - al secondo fuoco dell'immagine su righe / colonne null-indefinito)

function test(data) {
    if (data != null) {
        console.log('Data: ', data);
    }
}

test();          // the data=undefined
test(null);      // the data=null
test(undefined); // the data=undefined

test(0); 
test(false); 
test('something');

Qui hai tutto ( src ):

Se

== (la sua negazione ! = )

=== (la sua negazione ! == )

D: La funzione è stata chiamata senza argomenti, rendendo i dati una variabile indefinita e generando un errore sui dati! = Null.

A: Sì, datasarà impostato su indefinito. Vedere la sezione 10.5 Dichiarazione vincolante Istantanea della specifica. Ma l'accesso a un valore non definito non genera un errore. Probabilmente stai confondendo questo con l'accesso a una variabile non dichiarata in modalità rigorosa che genera un errore.

D: La funzione è stata chiamata specificamente con null (o non definito), come argomento, nel qual caso data! = Null protegge già il codice interno, rendendo && data! == undefined inutili.

D: La funzione è stata chiamata con un argomento non nullo, nel qual caso passerà banalmente entrambi i dati! = Null e data! == undefined.

A: Corretto. Si noti che i seguenti test sono equivalenti:

data != null
data != undefined
data !== null && data !== undefined

Vedere la sezione 11.9.3 L' algoritmo di confronto sull'uguaglianza astratta e la sezione 11.9.6. L'algoritmo di confronto sull'uguaglianza rigorosa della specifica.

Penso che testare le variabili per valori che non ti aspetti non sia una buona idea in generale. Perché il tuo test può essere considerato come scrivere una lista nera di valori proibiti. E se dimenticassi di elencare tutti i valori proibiti? Qualcuno, anche tu, può decifrare il tuo codice passando un valore inaspettato. Quindi un approccio più appropriato è qualcosa come la whitelisting: testare le variabili solo per i valori previsti, non inaspettati. Ad esempio, se si prevede che il valore dei dati sia una stringa, anziché questo:

function (data) {
  if (data != null && data !== undefined) {
    // some code here
    // but what if data === false?
    // or data === '' - empty string?
  }
}

fai qualcosa del genere:

function (data) {
  if (typeof data === 'string' && data.length) {
    // consume string here, it is here for sure
    // cleaner, it is obvious what type you expect
    // safer, less error prone due to implicit coercion
  } 
}

typeof foo === "undefined"è diverso da foo === undefined, non confonderli mai. typeof foo === "undefined"è ciò di cui hai veramente bisogno. Inoltre, utilizzare !==al posto di!=

Quindi la dichiarazione può essere scritta come

function (data) {
  if (typeof data !== "undefined" && data !== null) {
    // some code here
  }
}

Modificare:

Non è possibile utilizzare foo === undefinedper variabili non dichiarate.

var t1;

if(typeof t1 === "undefined")
{
  alert("cp1");
}

if(t1 === undefined)
{
  alert("cp2");
}

if(typeof t2 === "undefined")
{
  alert("cp3");
}

if(t2 === undefined) // fails as t2 is never declared
{
  alert("cp4");
}

Il modo semplice per eseguire il test è:

function (data) {
    if (data) { // check if null, undefined, empty ...
        // some code here
    }
}

var a;
alert(a); //Value is undefined

var b = "Volvo"; 
alert(b); //Value is Volvo

var c = null;
alert(c); //Value is null