JavaScript controlla se la variabile esiste (è definita / inizializzata)


Quale metodo per verificare se una variabile è stata inizializzata è migliore / corretto? (Supponendo che la variabile possa contenere qualsiasi cosa (stringa, int, oggetto, funzione, ecc.))

if (elem) { // or !elem

o

if (typeof(elem) !== 'undefined') {

o

if (elem != null) {


Answers



Vuoi l'operatore di tipo . In particolare:

if (typeof variable !== 'undefined') {
    // the variable is defined
}



L'operatore typeof controllerà se la variabile è davvero indefinita.

if (typeof variable === 'undefined') {
    // variable is undefined
}

L'operatore typeof , a differenza degli altri operatori, non genera un'eccezione ReferenceError quando viene utilizzata con una variabile non dichiarata.

Tuttavia, si noti che typeof null restituirà "object" . Dobbiamo stare attenti a evitare l'errore di inizializzare una variabile su null . Per sicurezza, questo è quello che potremmo usare invece:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Per maggiori informazioni sull'uso del confronto rigoroso === invece dell'uguaglianza semplice == , vedere:
Quale operatore uguale (== vs ===) dovrebbe essere utilizzato nei confronti JavaScript?




In JavaScript, è possibile definire una variabile, ma mantenere il valore undefined , in modo che la risposta più comune non sia tecnicamente corretta e invece esegua quanto segue:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

Questo potrebbe essere sufficiente per i tuoi scopi. Il seguente test ha semantica più semplice, il che rende più facile descrivere con precisione il comportamento del tuo codice e comprenderlo da solo (se ti interessano queste cose):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

Questo, naturalmente, presuppone che tu stia correndo in un browser (dove la window è un nome per l'oggetto globale). Ma se stai facendo un giro con i globals come questo probabilmente sei in un browser. Soggettivamente, l'uso di 'name' in window è stilisticamente coerente con l'uso di window.name per fare riferimento a globals. L'accesso ai globali come proprietà della window piuttosto che come variabili consente di ridurre al minimo il numero di variabili non dichiarate che si riferiscono al codice (a beneficio del linting) ed evita la possibilità che il proprio globale venga oscurato da una variabile locale. Inoltre, se i globals ti fanno accapponare la pelle potresti sentirti più a loro agio toccandoli solo con questo bastone relativamente lungo.




Nella maggior parte dei casi useresti:

elem != null

A differenza di un semplice if (elem) , consente 0 , false , NaN e '' , ma rifiuta null o undefined , rendendolo un buon test generale per la presenza di un argomento o proprietà di un oggetto.

Anche gli altri controlli non sono sbagliati, hanno solo usi diversi:

  • if (elem) : può essere usato se elem è garantito come oggetto, o se false , 0 , ecc. sono considerati valori "predefiniti" (quindi equivalenti a undefined o null ).

  • typeof elem == 'undefined' può essere usato nei casi in cui un valore null specificato ha un significato distinto per una variabile o una proprietà non inizializzata.

    • Questo è l'unico controllo che non genera un errore se elem non viene dichiarato (cioè nessuna istruzione var , non una proprietà di window , o non un argomento di funzione). Questo è, a mio avviso, piuttosto pericoloso in quanto consente agli errori di battitura di passare inosservati. Per evitare ciò, vedere il metodo seguente.

Utile anche un confronto rigoroso contro undefined :

if (elem === undefined) ...

Tuttavia, poiché il globale undefined può essere sostituito con un altro valore, è meglio dichiarare la variabile undefined nell'ambito corrente prima di utilizzarla:

var undefined; // really undefined
if (elem === undefined) ...

O:

(function (undefined) {
    if (elem === undefined) ...
})();

Un vantaggio secondario di questo metodo è che i minificatori JS possono ridurre la variabile undefined a un singolo carattere, risparmiando ogni volta qualche byte.




Come verificare se esiste una variabile

Questa è una soluzione piuttosto a prova di proiettile per testare se esiste una variabile ed è stata inizializzata:

var setOrNot = typeof variable !== typeof undefined;

È più comunemente usato in combinazione con un operatore ternario per impostare un valore predefinito nel caso in cui una determinata variabile non sia stata inizializzata:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Problemi con l'incapsulamento

Sfortunatamente, non puoi semplicemente incapsulare il tuo assegno in una funzione.

Potresti pensare di fare qualcosa del genere:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

Tuttavia, questo produrrà un errore di riferimento se chiami es. isset(foo) e variabile foo non sono stati definiti, perché non è possibile passare una variabile inesistente a una funzione:

Uncaught ReferenceError: foo non è definito

Verificare se i parametri della funzione non sono definiti

Sebbene la nostra funzione isset non possa essere utilizzata per verificare se una variabile esiste o meno (per le ragioni spiegate in precedenza), ci consente di verificare se i parametri di una funzione non sono definiti:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Anche se nessun valore per y viene passato al test funzioni, la nostra funzione isset funziona perfettamente in questo contesto, poiché y è conosciuto come test funzione come valore undefined .




Controlla se un oggetto hasOwnProperty()

Un'alternativa alla pletora di typeof risposte, è l'uso di hasOwnProperty() che ovviamente controlla se un oggetto (praticamente tutto in JS) ha una proprietà cioè una variabile (tra le altre cose).

Il metodo hasOwnProperty() restituisce un valore booleano che indica se l'oggetto ha la proprietà specificata come proprietà propria (non ereditata).

Ogni oggetto discendente da Object eredita il metodo hasOwnProperty() . Questo metodo può essere utilizzato per determinare se un oggetto ha la proprietà specificata come proprietà diretta di tale oggetto; a differenza dell'operatore in, questo metodo non controlla la catena del prototipo dell'oggetto.

// Globally established (therefore) properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
// window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ),             // true
    window.hasOwnProperty( "bar" ),             // true
    window.hasOwnProperty( "baz" ),             // true
    window.hasOwnProperty( "qux" ),             // false
    { foo: [], bar: 0 }.hasOwnProperty( "bar" ) // true
] );

La cosa fantastica di hasOwnProperty() è che nel chiamarla, non usiamo una variabile che potrebbe essere ancora indefinita - che ovviamente è metà del problema in primo luogo.

Sebbene non sia sempre la soluzione perfetta o ideale , in determinate circostanze, è proprio il lavoro!




C'è un altro modo per controllarlo quando esegui compiti semplici e assegni correlati. Basta usare l' operatore condizionale (Ternario).

var values = typeof variable !== 'undefined' ? variable : '';

Anche questo sarà utile quando proverai a dichiarare la variabile Globale con l'assegnazione di istanza della variabile di riferimento.

Se si desidera controllare la variabile non dovrebbe essere undefined o null . Quindi eseguire sotto controllo.

Quando la variabile viene dichiarata e se si desidera controllare il valore, questo è persino semplice: eseguirà controlli undefined o null insieme.

var values = variable ? variable : '';



indefinito, booleano, stringa, il numero, la funzione

if( typeof foo !== 'undefined' ) { 

}

Oggetto, Array

if( foo instanceof Array ) { 

}



Dipende se ti interessa solo che la variabile sia stata definita o se vuoi che abbia un valore significativo.

Controllando se il tipo non è definito controllerà se la variabile è stata ancora definita.

=== null o !== null controllerà solo se il valore della variabile è esattamente null .

== null o != null controllerà se il valore è undefined o null .

if(value) controllerà se la variabile undefined è undefined , null , 0 o una stringa vuota.




In molti casi, usando:

if (elem) { // or !elem

farà il lavoro per te ... questo controllerà i seguenti casi:

  1. indefinito : se il valore non è definito e non è undefined
  2. null : se è nullo, ad esempio se un elemento DOM non esiste ...
  3. stringa vuota : ''
  4. 0 : numero zero
  5. NaN : non un numero
  6. falso

Quindi coprirà il tipo di tutti i casi, ma ci sono sempre casi strani che vorremmo coprire, ad esempio una stringa con spazi, come questa ' ' , questo sarà definito in javascript in quanto ha spazi all'interno della stringa. .. per esempio in questo caso si aggiunge un altro controllo usando trim (), come:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Creo anche l'immagine qui sotto per mostrare un breve riassunto della risposta:




La risposta più alta è corretta, usa typeof.

Tuttavia, quello che volevo sottolineare era che in JavaScript undefined è mutabile (per qualche ragione non volgare). Quindi semplicemente fare un controllo per varName !== undefined ha il potenziale di non sempre ritornare come ci si aspetta, perché altre librerie potrebbero essere cambiate indefinite. Alcune risposte (@ skalee, per una), sembrano preferire non usare typeof , e questo potrebbe metterne uno nei guai.

Il "vecchio" modo di gestire questo era dichiarare indefinito come un var per compensare qualsiasi potenziale muting / over-riding di undefined . Tuttavia, il modo migliore è ancora di usare typeof perché ignorerà qualsiasi override di undefined da altro codice. Soprattutto se stai scrivendo il codice per l'uso in natura dove chissà cos'altro potrebbe essere in esecuzione sulla pagina ...




if (typeof console != "undefined") {    
   ...
}

O meglio

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Funziona su tutti i browser




È difficile distinguere tra non definito e nullo. Null è un valore che è possibile assegnare a una variabile quando si desidera indicare che la variabile non ha un valore particolare. Undefined è un valore speciale che sarà il valore predefinito delle variabili non assegnate.


var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);




Il più robusto 'è definito' il controllo è con typeof

if (typeof elem === 'undefined')

Se stai solo verificando la presenza di una variabile definita che assegna un valore predefinito, per una copertina di facile lettura puoi farlo spesso:

elem = elem || defaultElem;

Spesso è bene usare, vedi: Modo idiomatico per impostare il valore predefinito in javascript

C'è anche questo un liner con la parola chiave typeof :

elem = (typeof elem === 'undefined') ? defaultElem : elem;



puoi usare l'operatore typeof .

Per esempio,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

Lo snippet di codice riportato sopra restituirà l'output come

data set variabile è: undefined.




Null è un valore in JavaScript e typeof null restituisce "object"

Pertanto, la risposta accettata non funzionerà se si passano valori nulli. Se si passano valori nulli, è necessario aggiungere un controllo supplementare per i valori nulli:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}



Queste risposte (a parte la soluzione di Fred Gandt) sono tutte errate o incomplete.

Supponiamo di aver bisogno di mia variableName; portare un valore undefined , e quindi è stato dichiarato in un modo come var variableName; il che significa che è già inizializzato ; - Come posso verificare se è già stato dichiarato?

O ancora meglio: come posso verificare immediatamente se "Book1.chapter22.paragraph37" esiste con una singola chiamata, ma non aumentare un errore di riferimento?

Lo facciamo usando il più potente operatore JasvaScript, l'operatore in .:

"[variable||property]" in [context||root] 
>> true||false

In tempi di popolarità di AJAX, ho scritto un metodo (successivamente denominato) isNS () che è in grado di determinare se lo spazio dei nomi esiste, compresi i test approfonditi per nomi di proprietà come "Libro1.capitolo22.paragrafo37" e molto altro ancora.

Ma dal momento che è stato pubblicato in precedenza e per la sua grande importanza merita di essere pubblicato in una discussione separata, non lo posterò qui ma fornirà parole chiave ( javascript + isNS ) che ti aiuteranno a localizzare il codice sorgente, supportato da tutti i spiegazioni necessarie.




Nella particolare situazione descritta nella domanda,

typeof window.console === "undefined"

è identico a

window.console === undefined

Preferisco quest'ultimo dato che è più corto.

Si prega di notare che cerchiamo console solo in ambito globale (che è un oggetto window in tutti i browser). In questa particolare situazione è desiderabile. Non vogliamo che la console definita altrove.

@ BrianKelley nella sua grande risposta spiega i dettagli tecnici. Ho solo aggiunto la mancanza di conclusioni e l'ho digerito in qualcosa di più facile da leggere.




La mia preferenza è typeof(elem) != 'undefined' && elem != null .

Comunque tu scelga, considera di mettere il check in una funzione come questa

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

Se non sai che la variabile è dichiarata, continua con typeof (x) != 'undefined' && x != null;

Dove sai che la variabile è dichiarata ma potrebbe non esistere, potresti usarla

existy(elem) && doSomething(elem);

La variabile che stai controllando potrebbe essere a volte una proprietà annidata. Puoi usare il puntello || {} per andare sulla riga che controlla l'esistenza della proprietà in questione:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

Dopo ogni proprietà utilizzare (... '|| {}'). NextProp in modo che una proprietà mancante non genererà un errore.

O potresti usare existy come existy(o) && existy(op) && existy(opq) && doSomething(opq)




Dipende dalla situazione. Se stai cercando qualcosa che potrebbe essere o non essere stato definito globalmente al di fuori del tuo codice (come forse jQuery) vuoi:

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

(Non c'è bisogno di una rigorosa uguaglianza, typeof restituisce sempre una stringa.) Ma se si hanno argomenti per una funzione che può essere o non essere stata passata, saranno sempre definiti, ma null se omessi.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"



Per contribuire al dibattito, se so che la variabile dovrebbe essere una stringa o un oggetto, preferisco sempre if (!variable) , controllando quindi se è falsa. Questo può portare a un codice più pulito in modo che, ad esempio:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
        var message = 'Error receiving response';
        if (typeof data.error !== "undefined") {
            message = data.error;
        } else if (typeof data.message !== "undefined") {
            message = data.message;
        }
        alert(message); 
}

..potrebbe essere ridotto a:

if (data && !data.url) {
    var message = data.error || data.message || 'Error receiving response';
    alert(message)
} 



Io uso due modi diversi a seconda dell'oggetto.

if( !variable ){
  // variable is either
  // 1. empty string i.e. '';
  // 2. Integer 0;
  // 3. undefined;
  // 4. null;
}

A volte non voglio valutare una stringa vuota come falsa, quindi uso questo caso

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Se hai bisogno del contrario, allora in prima istanza! La variabile diventa !! variabile, e nella funzione non valida === diventa! = Ei nomi delle funzioni cambiano in nonInvalid.




Un po 'più funzionale e facile da usare:

function exist(obj)
{
    return (typeof obj !== 'undefined');
}

La funzione restituirà true se esiste, altrimenti false se non esiste.




Se vuoi che il blocco definito faccia qualcosa, usa questo

if (typeof variable !== 'undefined') {
    // the variable is defined
}

Se vuoi che il blocco non definito faccia qualcosa o assegni o definisca la variabile, allora usa questo

if (typeof variable === 'undefined') {
    // the variable is undefined
}



Che dire di un semplice:

if(!!variable){
  //the variable is defined
}



Per verificare se una variabile è stata dichiarata / impostata ho fatto questo trucco sporco.

Non ho trovato un modo per estrarre il codice da una funzione, anche con eval .

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}



Non sapendo se questo mi sarà d'aiuto, dovevo controllare se un Var che era stato definito sulla pagina venisse prelevato prima di eseguire gli script correlati e quanto segue funzionava bene per me.

if (window.myvar) { // run scripts here }

È un po 'semplice ma va bene per uno o più.




Non riesco a vederlo nelle risposte sopra, quindi lo suggerirò qui, immagino.

function isDefined(x) { return !!x }

if( isDefined(x) ) {
    //The variable is defined
}

! x restituirà true iff x è nullo o non definito , quindi !! x restituirà solo vero iff x non è né indefinito né nullo.

Mi rendo conto che questo spiega anche il caso nullo, ma ecco un giusto avvertimento a riguardo.