Come controllare una variabile non definita in JavaScript


913

Volevo verificare se la variabile è definita o meno. Ad esempio, quanto segue genera un errore non definito

alert( x );

Come posso rilevare questo errore?




1
Questo non è un duplicato del duplicato contrassegnato. La risoluzione variabile e la risoluzione delle proprietà degli oggetti sono cose molto diverse. Un duplicato migliore è come verificare se esiste una variabile in JavaScript? .
RobG,

Il tuo errore è dovuto alla variabile non dichiarata. La maggior parte delle risposte è incentrata sull'assegnazione. Vedi la mia risposta per di più. Inoltre, molti di essi affermano erroneamente che null e indefinito sono oggetti in JavaScript. Sono primitivi , non oggetti ...
JBallin,

Risposte:


1691

In JavaScript, nullè un oggetto. C'è un altro valore per le cose che non esistono, undefined. Il DOM ritorna nullper quasi tutti i casi in cui non riesce a trovare una struttura nel documento, ma in JavaScript stesso undefinedè il valore utilizzato.

Secondo, no, non esiste un equivalente diretto. Se vuoi davvero controllare specificamente per null, fai:

if (yourvar === null) // Does not execute if yourvar is `undefined`

Se vuoi verificare se esiste una variabile, ciò può essere fatto solo con try/ catch, poiché typeoftratterà una variabile non dichiarata e una variabile dichiarata con il valore di undefinedequivalente.

Ma, per verificare se una variabile è dichiarata e non lo è undefined:

if (yourvar !== undefined) // Any scope

In precedenza, era necessario utilizzare l' typeofoperatore per verificare la sicurezza non definita, poiché era possibile riassegnare undefinedcome una variabile. Il vecchio modo assomigliava a questo:

if (typeof yourvar !== 'undefined') // Any scope

Il problema della undefinedriassegnabilità è stato risolto in ECMAScript 5, che è stato rilasciato nel 2009. Ora è possibile utilizzare ===e !==testare in sicurezza undefinedsenza utilizzare, typeofpoiché undefinedè stato di sola lettura per un po 'di tempo.

Se vuoi sapere se un membro esiste indipendentemente ma non importa quale sia il suo valore:

if ('membername' in object) // With inheritance
if (object.hasOwnProperty('membername')) // Without inheritance

Se vuoi sapere se una variabile è vera :

if (yourvar)

fonte


71
non definito non è una parola riservata; tu (o il codice di qualcun altro) puoi fare "undefined = 3" e questo interromperà due dei tuoi test.
Jason S,

6
"Se sai che la variabile esiste ma non sai se c'è qualche valore memorizzato in essa" - eh ?!
Jason S,

36
Penso che si riferisca a una variabile dichiarata a cui non è stata assegnata. ad esempio: var foo; // foo esiste ma non ha un valore
Wally Lawless

3
Hmmm ... Ho appena notato il link "fonte": l'intero post è una citazione diretta da una mailing list e probabilmente dovrebbe essere modificato per renderlo più chiaro, poiché l'autore originale non è disponibile per chiarire.
Jason S,

11
"In JavaScript null è un oggetto.", In realtà non è vero, e probabilmente il colpevole di questo malinteso è l' typeofoperatore ( typeof null == 'object'). Il nullvalore è un valore primitivo , che è l'unico valore del tipo Null .
CMS,

347

L'unico modo per testare veramente se una variabile è undefinedfare quanto segue. Ricorda, undefined è un oggetto in JavaScript.

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

Alcune delle altre soluzioni in questo thread ti faranno credere che una variabile sia indefinita anche se è stata definita (con un valore NULL o 0, per esempio).


18
Perché la domanda era NON DEVE ESSERE DEFINITA qui dovrebbe essere typeof someVar! == 'undefined', giusto?
Eomeroff,

1
Davvero, non credo che undefinded sia un oggetto, controlla prima la documentazione developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures
Nicramus,

2
L'unico test che non produce a ReferenceError.
Nostalg.io

2
Questo codice è corretto, ma penso che dire che undefinedun oggetto in JavaScript sia disinformazione. Questa affermazione si riferisce comunque alla tua risposta? È un valore undefineddi tipo undefined, assegnato all'identificatore globale denominato undefined.
Semplicemente il

1
Questo ora non è corretto in quanto è l'unico modo. undefinedè stato di sola lettura da ES5. È possibile verificare in modo sicuro per l'utilizzo di indefinito if (x === undefined) {...}o utilizzando scorciatoia in questo modo: if (x === void 0).
Stephen M Irving,

66

Tecnicamente, la soluzione corretta è (credo):

typeof x === "undefined"

A volte puoi diventare pigro e usare

x == null

ma ciò consente sia a una variabile non definita x, sia a una variabile x contenente null, di restituire true.


1
se digiti var x;e poi typeof x;otterrai "undefined"esattamente come hai fatto tutypeof lakjdflkdsjflsj;
Muhammad Umer,

Quindi non c'è modo di verificare la presenza di variabili non definite ma dichiarate?
Muhammad Umer,

1
Io non la penso così; Non sono sicuro del motivo per cui vorresti farlo.
Jason S,

ujndefined non dovrebbe essere tra gli apici
LowFieldTheory

cosa intendi per apice?
Jason S

19

Una versione ancora più semplice e più abbreviata sarebbe:

if (!x) {
   //Undefined
}

O

if (typeof x !== "undefined") {
    //Do something since x is defined.
}

26
il primo pezzo di codice può essere errato se x viene impostato da una chiamata di funzione. come x = A (); se A non restituisce nulla, restituirà "non definito" per impostazione predefinita. Fare un! X sarebbe vero e logicamente corretto. Tuttavia, se A () restituisce 0, allora! X dovrebbe essere falso come x = 0. Tuttavia in JS,! 0 è anche vero.
Rajat,

il secondo codice può essere abbreviato in: if (! typeof (XX)) {...} else {...}
Alejandro Silva

2
@AlejandroSilva Ci scusiamo per la risposta tardiva. Ciò non funzionerà poiché typeof restituisce una stringa, quindi restituirà "undefined" per una variabile non definita, che a sua volta verrà valutata come TRUE, portando quindi a un falso positivo di una var definita.
Dmitri Farkov,

5
Per favore, sbarazzati del primo frammento, è solo male
Juan Mendes,

1
Altri commenti hanno sottolineato che il primo esempio è negativo, ma non chiaramente perché. Quindi, per ogni nuovo programmatore:! X non verifica se x è definito, ma se è vero. Stringhe, valori booleani veri e numeri positivi sono tutti veritieri (e potrei dimenticare alcune cose), ma altri valori potenzialmente validi come 0, booleano falso e una stringa vuota non sono veritieri. Il primo esempio può funzionare per casi d'uso specifici (ad esempio, test per una stringa se si può trattare vuoto uguale a non definito), ma a causa dei molti dove non lo farà, non dovrebbe essere considerato il modo predefinito di verificare.
cfr

16

Ho fatto spesso:

function doSomething(variable)
{
    var undef;

    if(variable === undef)
    {
         alert('Hey moron, define this bad boy.');
    }
}

9
Valuta di cambiare "==" in "===". Se chiami doSomething (null) riceverai anche l'avviso. A meno che non sia quello che vuoi.
Jason S,

Sì. Devi decidere se vuoi equivalente o esattamente uguale. In entrambi i casi potrebbe essere utile.
Joe,

1
controlla semplicemente in questo modo-> if (typeof variabileName! == 'undefined') {alert (variabileName);}
Muhammad Sadiq,

questo è inutile poiché non sarai in grado di passare comunque una var indefinita a una funzione
valanga1

2
Certo che puoi. Prova a chiamare una funzione senza argomenti.
Joe,

3

Puoi anche usare l'operatore condizionale ternario:

var a = "hallo world";
var a = !a ? document.write("i dont know 'a'") : document.write("a = " + a);

//var a = "hallo world";
var a = !a ? document.write("i dont know 'a'") : document.write("a = " + a);


E se var a = false;? Dovresti verificare che se a===undefinedinvece
Iter Ator,

1
Domanda: controlla una variabile non definita ..... Questa è una variabile non definita: var x; fare sopra genererà un errore
Muhammad Umer,

"Se a = false, allora mostrerà" non so 'a' "" - Questo è il problema, la domanda è verificare se è definito, non se è vero. Se a è definito come falso, allora a non è indefinito. Questo restituisce il risultato sbagliato in quel caso. Vedi il mio commento su stackoverflow.com/a/858270/2055492 per maggiori dettagli sul perché questo approccio non funziona.
cfr

non solo !atesterà true per undefined, ma testerà anche true per 0e nulle false. Questo è molto errato e dovrebbe essere rimosso.
Stephen M Irving,

2

Uso spesso il modo più semplice:

var variable;
if (variable === undefined){
    console.log('Variable is undefined');
} else {
    console.log('Variable is defined');
}

MODIFICARE:

Senza inizializzare la variabile, verrà generata un'eccezione "Uncaught ReferenceError: variabile non definita ..."


2
Uncaught ReferenceError: variable is not defined
Muhammad Umer,

@MuhammadUmer, sbagliato! variableè definito da var variable;. E questo frammento avrà variablela precedenza sull'ambito locale. Può rompere la logica che prevede di accedere a una chiusura o a una variabile globale. var variable = 1; function test() { var variable; if (variable === undefined){ console.log('Variable is undefined'); } else { console.log('Variable is defined: ' + variable); } } test(); // Variable is undefined
Vale a

2

Un'altra potenziale "soluzione" è usare l' windowoggetto. Evita il problema dell'errore di riferimento in un browser.

if (window.x) {
    alert('x exists and is truthy');
} else {
    alert('x does not exist, or exists and is falsy');
}

Questo non risolve affatto la domanda originale ed è totalmente irrilevante. Poster non stava chiedendo come testare se qualcosa è vero o falso, ha chiesto come testare undefined. Questo non lo farà.
Stephen M Irving,

2

L'errore ti sta dicendo che xnon esiste nemmeno! Non è stato dichiarato , il che è diverso dall'assegnare un valore.

var x; // declaration
x = 2; // assignment

Se lo dichiarassi x, non otterrai un errore. Riceverai un avviso che dice undefinedperché xesiste / è stato dichiarato ma non è stato assegnato un valore.

Per verificare se la variabile è stata dichiarata, è possibile utilizzare typeofqualsiasi altro metodo per verificare l'esistenza di una variabile genererà lo stesso errore che si è verificato inizialmente.

if(typeof x  !==  "undefined") {
    alert(x);
}

Questo sta controllando il tipo di valore memorizzato in x. Restituirà solo undefinedquando xnon è stato dichiarato OPPURE se è stato dichiarato e non è stato ancora assegnato.


undefined è stato di sola lettura da ES5 (versione 2009) e non è più necessario l' typeofoperatore.
Stephen M Irving,

2

L' voidoperatore ritorna undefinedper qualsiasi argomento / espressione passato ad esso. così puoi testare il risultato (in realtà alcuni minimizzatori cambiano il tuo codice da undefinedavoid 0 per salvare un paio di caratteri)

Per esempio:

void 0
// undefined

if (variable === void 0) {
    // variable is undefined
}

Ding Ding! Questa è la risposta corretta Peccato che sia tutto in fondo. Tutti sono così bloccati dal continuare a usare typeofe pensare undefinedpuò essere riassegnato, cosa impossibile da circa un decennio.
Stephen M Irving,

Questo era anche sicuro prima di ES5 perché allora anche se lo avessi riassegnato undefined, perché Dio sa solo quale motivo, l'utilizzo void 0tornerà sempre a undefinedprescindere.
Stephen M Irving,

1

Possiamo controllare undefinedcome segue

var x; 

if (x === undefined) {
    alert("x is undefined");
} else {
     alert("x is defined");
}

1

Fai semplicemente qualcosa come di seguito:

function isNotDefined(value) {
  return typeof value === "undefined";
}

e chiamalo come:

isNotDefined(undefined); //return true
isNotDefined('Alireza'); //return false

0

La risposta accettata è corretta Volevo solo aggiungere un'altra opzione. È inoltre possibile utilizzare il try ... catchblocco per gestire questa situazione. Un bizzarro esempio:

var a;
try {
    a = b + 1;  // throws ReferenceError if b is not defined
} 
catch (e) {
    a = 1;      // apply some default behavior in case of error
}
finally {
    a = a || 0; // normalize the result in any case
}

Fai attenzione al catchblocco, che è un po 'disordinato, in quanto crea un ambito a livello di blocco. E, naturalmente, l'esempio è estremamente semplificato per rispondere alla domanda posta, non copre le migliori pratiche nella gestione degli errori;).


0

Uso una piccola funzione per verificare che una variabile sia stata dichiarata, il che riduce davvero la quantità di disordine nei miei file javascript. Aggiungo un controllo per il valore per assicurarsi che la variabile non solo esista, ma sia stata anche assegnata un valore. La seconda condizione controlla se anche la variabile è stata istanziata, perché se la variabile è stata definita ma non istanziata (vedere l'esempio seguente), verrà comunque generato un errore se si tenta di fare riferimento al suo valore nel codice.

Non istanziato - var my_variable;Istanziato -var my_variable = "";

function varExists(el) { 
  if ( typeof el !== "undefined" && typeof el.val() !== "undefined" ) { 
    return true; 
  } else { 
    return false; 
  } 
}

È quindi possibile utilizzare un'istruzione condizionale per verificare che la variabile sia stata definita E istanziata in questo modo ...

if ( varExists(variable_name) ) { // checks that it DOES exist } 

o per verificare che non sia stato definito e istanziato usare ...

if( !varExists(variable_name) ) { // checks that it DOESN'T exist }

1
Perché non restituire subito il tuo predicato? return typeof el !== "undefined" && typeof el.val() !== "undefined"
skubski
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.