read - Come verificare la presenza di "non definito" in JavaScript?




javascript undefined int (11)

Aggiornamento 2018-07-25

Sono trascorsi quasi cinque anni da quando questo post è stato realizzato per la prima volta, e JavaScript ha fatto molta strada. Nel ripetere i test nel post originale, non ho riscontrato differenze consistenti tra i seguenti metodi di test:

  • abc === undefined
  • abc === void 0
  • typeof abc == 'undefined'
  • typeof abc === 'undefined'

Anche quando ho modificato i test per impedire a Chrome di ottimizzarli, le differenze erano insignificanti. Come tale, ora consiglierei abc === undefined per chiarezza.

Contenuti rilevanti di chrome://version :

  • Google Chrome: 67.0.3396.99 (Build ufficiale) (64-bit) (coorte: stabile)
  • Revisione: a337fbf3c2ab8ebc6b64b0bfdce73a20e2e2252b-refs / branch-heads / 3396 @ {# 790}
  • Sistema operativo: Windows
  • JavaScript: V8 6.7.288.46
  • Agente utente: Mozilla / 5.0 (Windows NT 10.0; Win64; x64) AppleWebKit / 537.36 (KHTML, come Gecko) Chrome / 67.0.3396.99 Safari / 537.36

Post originale 2013-11-01

In Google Chrome, il seguente è stato sempre leggermente più veloce di un test di tipo:

if (abc === void 0) {
    // Undefined
}

La differenza era trascurabile. Tuttavia, questo codice è più conciso, e più chiaro a colpo d'occhio a qualcuno che sa cosa vuol dire void 0 . Nota, tuttavia, che abc deve ancora essere dichiarato.

Sia typeof che void erano significativamente più veloci rispetto al confronto diretto con undefined . Ho utilizzato il seguente formato di test nella console degli sviluppatori di Chrome:

var abc;
start = +new Date();
for (var i = 0; i < 10000000; i++) {
    if (TEST) {
        void 1;
    }
}
end = +new Date();
end - start;

I risultati sono stati i seguenti:

Test: | abc === undefined      abc === void 0      typeof abc == 'undefined'
------+---------------------------------------------------------------------
x10M  |     13678 ms               9854 ms                 9888 ms
  x1  |    1367.8 ns              985.4 ns                988.8 ns

Si noti che la prima riga è in milli secondi, mentre la seconda riga è in nano secondi. Una differenza di 3,4 nanosecondi non è nulla. I tempi erano abbastanza consistenti nei test successivi.

Qual è il modo più appropriato per verificare se una variabile non è definita in JavaScript? Ho visto diversi modi possibili:

if (window.myVariable)

O

if (typeof(myVariable) != "undefined")

O

if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?

Al contrario della risposta di @Thomas Eding:

Se dimentico di dichiarare myVar nel mio codice, myVar is not defined .

Facciamo un esempio reale:

Ho un nome variabile, ma non sono sicuro che sia stato dichiarato da qualche parte o meno.

Quindi la risposta di @ Anurag aiuterà:

var myVariableToCheck = 'myVar';
if (window[myVariableToCheck] === undefined)
    console.log("Not declared or declared, but undefined.");

// Or you can check it directly 
if (window['myVar'] === undefined) 
    console.log("Not declared or declared, but undefined.");

Devi usare typeof .

if (typeof something != "undefined") {
    // ...
}

Il modo più affidabile che conosca per il controllo di undefined è l'utilizzo di void 0 .

Questo è compatibile con i browser più vecchi e nuovi, allo stesso modo, e non può essere sovrascritto come window.undefined può in alcuni casi.

if( myVar === void 0){
    //yup it's undefined
}

Io personalmente uso

myVar === undefined

Avvertenza: si prega di notare che === è usato su == e che myVar è stato precedentemente dichiarato (non definito ).

Non mi piace il typeof myVar === "undefined" . Penso che sia lungo e inutile. (Posso ottenere lo stesso risultato con meno codice.)

Ora alcune persone si lamenteranno per il dolore quando leggono questo, urlando: "Aspetta, WAAITTT !!! undefined può essere ridefinito!"

Freddo. Lo so. Inoltre, la maggior parte delle variabili in Javascript può essere ridefinita. Non dovresti mai usare un identificatore integrato che possa essere ridefinito?

Se segui questa regola, fa bene a te: non sei un ipocrita.

Il fatto è che, per fare un sacco di lavoro reale in JS, gli sviluppatori devono affidarsi a identificatori ridefinibili per essere quello che sono. Non sento le persone che mi dicono che non dovrei usare setTimeout perché qualcuno può farlo

window.setTimeout = function () {
    alert("Got you now!");
};

In conclusione, l'argomento "può essere ridefinito" per non usare un raw === undefined è fasullo.

(Se hai ancora paura di ridefinire un undefined , perché stai integrando ciecamente codice di libreria non testato nella tua base di codice? O ancora più semplice: uno strumento di sfilacciamento.)

Inoltre, come l'approccio typeof , questa tecnica può "rilevare" le variabili non dichiarate:

if (window.someVar === undefined) {
    doSomething();
}

Ma entrambe queste tecniche perdono nella loro astrazione. Vi esorto a non usare questo o addirittura

if (typeof myVar !== "undefined") {
    doSomething();
}

Tenere conto:

var iAmUndefined;

Per capire se la variabile è dichiarata o meno, potrebbe essere necessario ricorrere all'operatore in. (In molti casi, puoi semplicemente leggere il codice O_o).

if ("myVar" in window) {
    doSomething();
}

Ma aspetta! C'è più! Cosa succede se qualche prototipo di magia della catena sta accadendo ...? Ora nemmeno l'operatore superiore in non è sufficiente. (Ok, ho finito qui per questa parte eccetto per dire che per il 99% delle volte, === undefined (e **** cough **** typeof ) funziona bene. Se ti interessa davvero, puoi leggi di questo argomento da solo.)


Lo uso come parametro di funzione e lo escludo nell'esecuzione della funzione in questo modo ottengo il "reale" indefinito. Sebbene richieda di inserire il codice in una funzione. Ho trovato questo durante la lettura della fonte jQuery.

undefined = 2;

(function (undefined) {
   console.log(undefined); // prints out undefined
   // and for comparison:
   if (undeclaredvar === undefined) console.log("it works!")
})()

Ovviamente potresti usare solo typeof . Ma tutto il mio codice è in genere all'interno di una funzione di contenimento comunque, quindi l'utilizzo di questo metodo probabilmente mi consente di risparmiare qualche byte qua e là.


Poiché nessuna delle altre risposte mi ha aiutato, suggerisco di farlo. Ha funzionato per me in Internet Explorer 8:

if (typeof variable_name.value === 'undefined') {
    // variable_name is undefined
}

Se non è definito, non sarà uguale a una stringa che contiene i caratteri "non definito", in quanto la stringa non è indefinita.

Puoi controllare il tipo di variabile:

if (typeof(something) != "undefined") ...

A volte non devi nemmeno controllare il tipo. Se il valore della variabile non può essere valutato come falso quando è impostato (ad esempio se si tratta di una funzione), puoi semplicemente valutare la variabile. Esempio:

if (something) {
  something(param);
}

Usare typeof è la mia preferenza. Funzionerà quando la variabile non è mai stata dichiarata, diversamente da qualsiasi confronto con gli operatori == o === o la coercizione di tipo che usa if . ( undefined , a differenza di null , può anche essere ridefinito negli ambienti ECMAScript 3, rendendolo inaffidabile per il confronto, sebbene quasi tutti gli ambienti comuni ora siano compatibili con ECMAScript 5 o successivi).

if (typeof someUndeclaredVariable == "undefined") {
    // Works
}

if (someUndeclaredVariable === undefined) { 
    // Throws an error
}

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

    /* One more thing to understand: typeof ==='undefined' also checks 
       for if a variable is declared, but no value is assigned. In other 
       words, the variable is declared, but not defined. */

    // Will repeat above logic of x for typeof === 'undefined'
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    /* So typeof === 'undefined' works for both, but x === undefined 
       only works for a variable which is at least declared. */

    /* Say if I try using typeof === undefined (not in quotes) for 
       a variable which is not even declared, we will get run a 
       time error. */

    if (z === undefined) {
        alert ("I am neither declared nor defined.")
    };
    // I got this error for z ReferenceError: z is not defined 

if (typeof foo == 'undefined') {
 // Do something
};

Nota che il confronto rigoroso ( !== ) non è necessario in questo caso, dal momento che typeof restituirà sempre una stringa.





undefined