Come controllare una variabile non definita in JavaScript

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

alert( x );

Come posso rilevare questo errore?

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

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

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.

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

if (!x) {
   //Undefined
}

O

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

Ho fatto spesso:

function doSomething(variable)
{
    var undef;

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

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

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 ..."

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');
}

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.

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
}

Possiamo controllare undefinedcome segue

var x; 

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

Fai semplicemente qualcosa come di seguito:

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

e chiamalo come:

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

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;).

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 }