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) {

Vuoi l' typeofoperatore . In particolare:

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

L' typeofoperatore verificherà se la variabile non è veramente definita.

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

L' typeofoperatore, a differenza degli altri operatori, non genera un'eccezione ReferenceError se utilizzato con una variabile non dichiarata.

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

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

Per maggiori informazioni sull'uso del confronto rigoroso ===anziché della semplice uguaglianza ==, vedi:
Quale operatore uguale (== vs ===) dovrebbe essere usato nei confronti JavaScript?

In molti casi, usando:

if (elem) { // or !elem

farà il lavoro per te! ... questo controllerà questi casi di seguito:

1. undefined : se il valore non è definito ed èundefined
2. null : se è null, 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 genere di tutti i casi, ma ci sono sempre casi strani che vorremmo coprire anche, ad esempio, una stringa con spazi, come questa ' ', questa sarà definita in javascript poiché ha spazi all'interno della stringa ... ad esempio in questo caso aggiungi un altro controllo usando trim (), come:

if(elem) {

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

Inoltre, questi controlli sono solo per valori , poiché gli oggetti e le matrici funzionano in modo diverso in Javascript, gli array []vuoti e gli oggetti vuoti {}sono sempre veri .

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

In JavaScript, è possibile definire una variabile, ma mantenere il valore undefined, quindi la risposta più comune non è tecnicamente corretta e invece esegue le seguenti operazioni:

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 una semantica più semplice, che semplifica la descrizione precisa del comportamento del codice e la sua comprensione (se ci tenete a tali cose):

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

Questo, ovviamente, presuppone che tu sia in esecuzione in un browser (dove windowè un nome per l'oggetto globale). Ma se vai in giro con globi come questo, probabilmente sei in un browser. Soggettivamente, l'utilizzo 'name' in windowè stilisticamente coerente con l'uso window.nameper riferirsi ai globali. L'accesso ai globi come proprietà windowanziché come variabili consente di ridurre al minimo il numero di variabili non dichiarate a cui si fa riferimento nel proprio codice (a vantaggio della sfilacciatura) ed evitare la possibilità che il proprio globale venga oscurato da una variabile locale. Inoltre, se i globuli fanno strisciare la pelle, potresti sentirti più a tuo agio toccandoli solo con questo bastone relativamente lungo.

Nella maggior parte dei casi useresti:

elem != null

A differenza di un semplice if (elem), permette 0, false, NaNe '', ma scarti nullo undefined, rendendolo una buona, prova generale per la presenza di un argomento o una proprietà di un oggetto.

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

• if (elem): Può essere utilizzato se elemviene garantita un oggetto, o se false, 0ecc sono considerati i valori di "default" (quindi equivalente undefinedo null).

• typeof elem == 'undefined'può essere utilizzato nei casi in cui uno specificato nullha un significato distinto per una variabile o proprietà non inizializzata.

  • Questo è l'unico controllo che non genererà un errore se elemnon viene dichiarato (ovvero nessuna varistruzione, non una proprietà windowo un argomento della funzione). Questo, a mio avviso, è piuttosto pericoloso in quanto consente ai refusi di passare inosservati. Per evitare ciò, vedere il metodo seguente.

Utile anche un rigido confronto con undefined:

if (elem === undefined) ...

Tuttavia, poiché il globale undefinedpuò essere sostituito con un altro valore, è consigliabile dichiarare la variabile undefinednell'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 undefinedvariabile a un singolo carattere, facendoti risparmiare qualche byte ogni volta.

Controlla se window. hasOwnProperty( " varname" )

Un'alternativa alla pletora di typeofrisposte;

Variabili globali dichiarate con var varname = value;un'istruzione nell'ambito globale

è possibile accedere come proprietà dell'oggetto finestra.

Come tale, il hasOwnProperty()metodo, che

restituisce un valore booleano che indica se l'oggetto ha la proprietà specificata come propria proprietà (anziché ereditarla)

può essere usato per determinare se

a vardi "varname" è stato dichiarato a livello globale, ovvero è una proprietà di window.

// 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
] );

La cosa grandiosa hasOwnProperty()è che nel chiamarlo non usiamo una variabile che potrebbe non essere ancora dichiarata - che ovviamente è la metà del problema in primo luogo.

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

Appunti

Quanto sopra è vero quando si utilizza varper definire una variabile , al contrario del letquale:

dichiara una variabile locale dell'ambito del blocco, inizializzandola facoltativamente su un valore.

è diverso dal var parola chiave, che definisce una variabile a livello globale o localmente a un'intera funzione indipendentemente dall'ambito del blocco.

Al livello superiore di programmi e funzioni, a letdifferenza di var, non crea una proprietà sull'oggetto globale.

Per completezza: le const costanti sono, per definizione, in realtà non variabili (sebbene il loro contenuto possa essere); più pertinente:

Le costanti globali non diventano proprietà dell'oggetto finestra, a differenza delle varvariabili. È richiesto un inizializzatore per una costante; cioè, è necessario specificare il suo valore nella stessa istruzione in cui è dichiarato.

Il valore di una costante non può cambiare attraverso la riassegnazione e non può essere nuovamente dichiarato.

La dichiarazione const crea un riferimento di sola lettura a un valore. Non significa che il valore che detiene sia immutabile, ma solo che l'identificatore di variabile non può essere riassegnato.

Poiché le letvariabili o le constcostanti non sono mai proprietà di alcun oggetto che ha ereditato il hasOwnProperty()metodo, non può essere utilizzato per verificarne l'esistenza.

Per quanto riguarda la disponibilità e l'uso di hasOwnProperty():

Ogni oggetto discendente da Object eredita il hasOwnProperty()metodo. [...] a differenza indell'operatore, questo metodo non controlla la catena di prototipi dell'oggetto.

Come verificare se esiste una variabile

Questa è una soluzione piuttosto a prova di proiettile per verificare 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 controllo 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 si chiama ad es. isset(foo)e la variabile foonon è stata definita, poiché non è possibile passare una variabile inesistente a una funzione:

Errore di riferimento non rilevato: foo non è definito

Verifica se i parametri della funzione non sono definiti

Sebbene la nostra issetfunzione non possa essere utilizzata per verificare l'esistenza o meno di una variabile (per motivi illustrati 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 yviene passato alla funzione test, la nostra issetfunzione funziona perfettamente in questo contesto, perché yè noto nella funzione testcome undefinedvalore.

Esiste un altro modo breve per verificarlo, quando si eseguono compiti semplici e controlli correlati. Basta usare l' operatore condizionale (ternario).

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

Inoltre, ciò sarà utile quando si tenta di dichiarare la variabile globale con l'assegnazione dell'istanza della variabile di riferimento.

Se si desidera controllare la variabile non dovrebbe essere undefinedo null. Quindi eseguire il controllo di seguito.

Quando viene dichiarata la variabile e se si desidera verificare il valore, questo è persino Semplice: e verrebbe eseguito undefinede nullverificato insieme.

var values = variable ? variable : '';

Il modo breve per testare una variabile non è dichiarato (non definito) è

if (typeof variable === "undefined") {
  ...
}

L'ho trovato utile per rilevare script in esecuzione all'esterno di un browser (non avendo dichiarato windowvariabile).

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

Controllare se il tipo non è definito verificherà se la variabile è stata ancora definita.

=== nullo !== nullcontrollerà solo se il valore della variabile è esattamente null.

== nullo != nullcontrollerà se il valore è undefinedo null.

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

La risposta più alta è corretta, usa typeof.

Tuttavia, ciò che volevo sottolineare era che in JavaScript undefinedè mutevole (per qualche ragione empia). Quindi, semplicemente fare un controllo per varName !== undefinedha il potenziale di non tornare sempre come previsto, perché altre librerie potrebbero essere cambiate indefinite. Alcune risposte (@ skalee's, per esempio), sembrano preferire non utilizzarle typeof, e ciò potrebbe mettere nei guai.

Il "vecchio" modo di gestire ciò stava dichiarando indefinito come var per compensare l'eventuale muting / over-riding di undefined. Tuttavia, il modo migliore è ancora quello di utilizzare typeofperché ignorerà qualsiasi sostituzione undefinedda altro codice. Soprattutto se stai scrivendo 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 in tutti i browser

Per contribuire al dibattito, se so che la variabile dovrebbe essere una stringa o un oggetto che preferisco sempre if (!variable), quindi controlla 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)
} 

È difficile distinguere tra indefinito 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);

Null è un valore in JavaScript e typeof nullrestituisce"object"

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

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

Il controllo più affidabile "è definito" è con typeof

if (typeof elem === 'undefined')

Se stai solo cercando una variabile definita per assegnare un valore predefinito, per una riga di facile lettura puoi spesso farlo:

elem = elem || defaultElem;

Spesso va bene usare, vedi: Modo idiomatico per impostare il valore predefinito in JavaScript

C'è anche questo liner che usa la parola chiave typeof :

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

puoi usare l' typeofoperatore.

Per esempio,

var dataSet;

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

Lo snippet di codice sopra restituirà l'output come

variabile dataSet è: non definito.

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

Non ho trovato un modo per estrarre il codice in 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");
}

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

Supponiamo che io abbia bisogno che io variableName;porti un undefinedvalore, e quindi è stato dichiarato in un modo tale var variableName;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 genera un errore di riferimento?

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

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

In tempi di popolarità di AJAX ho scritto un metodo (in seguito denominato) isNS () che è in grado di determinare se esiste lo spazio dei nomi, compresi test approfonditi per nomi di proprietà come "Book1.chapter22.paragraph37" e molto altro.

Ma dal momento che è stato precedentemente pubblicato e per la sua grande importanza merita di essere pubblicato in un thread separato, non lo posterò qui ma fornirò parole chiave ( javascript + isNS ) che ti aiuteranno a individuare il codice sorgente, supportato da tutto il spiegazioni necessarie.

Nella particolare situazione descritta nella domanda,

typeof window.console === "undefined"

è identico a

window.console === undefined

Preferisco quest'ultima poiché è più corta.

Si noti che cerchiamo consolesolo nell'ambito globale (che è un windowoggetto in tutti i browser). In questa situazione particolare è desiderabile. Non vogliamoconsole definito altrove.

@BrianKelley nella sua grande risposta spiega i dettagli tecnici. Ho solo aggiunto delle conclusioni mancanti e le ho digerite in qualcosa di più facile da leggere.

Uso due modi diversi a seconda dell'oggetto.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

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, nella prima istanza la variabile! Diventa !! variabile e nella funzione non valida === diventa! = E i nomi delle funzioni cambiano in notInvalid.

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

Comunque tu scelga, considera di mettere la spunta 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, puoi usare

existy(elem) && doSomething(elem);

La variabile che si sta controllando può essere talvolta una proprietà nidificata. Puoi usare prop || {} per scendere in riga controllando l'esistenza della proprietà in questione:

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

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

Oppure potresti usare esisty come existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Dipende dalla situazione. Se stai cercando qualcosa che potrebbe o non potrebbe 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 lì, typeof restituisce sempre una stringa.) Ma se hai argomenti per una funzione che può o non può essere stata passata, saranno sempre definiti, ma nulli se omessi.

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

Prova a prendere

Se la variabile non è stata definita affatto, è possibile verificarla senza eseguire il codice di interruzione utilizzando il blocco try-catch come segue (non è necessario use strictattivare la modalità)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BONUS: (riferendosi ad altre risposte) Perché ===è più chiaro di ==( fonte )

if (a == b)

se (a === b)

Sono sorpreso che non sia stato ancora menzionato ...

qui ci sono un paio di varianti aggiuntive usando this['var_name']

il vantaggio dell'utilizzo di questo metodo che può essere utilizzato prima che venga definita una variabile.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

È possibile utilizzare un blocco try ... catch come il seguente:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Uno svantaggio è che non puoi metterlo in una funzione in quanto genererebbe un ReferenceError

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))