Jak sprawdzić nie zdefiniowaną zmienną w JavaScript

Jedynym sposobem, aby naprawdę sprawdzić, czy zmienna jest undefined, jest wykonanie następujących czynności. Pamiętaj, że undefined jest obiektem w JavaScript.

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

Niektóre z innych rozwiązań w tym wątku doprowadzą cię do przekonania, że zmienna jest niezdefiniowana, mimo że została zdefiniowana (np. z wartością NULL lub 0).

Technicznie, właściwe rozwiązanie jest (wierzę):

typeof x === "undefined"

Czasami można się leniwie i używać

x == null

Ale to pozwala zarówno niezdefiniowanej zmiennej x, jak i zmiennej x zawierającej null, zwracać true.

Jeszcze łatwiejszą i bardziej skróconą wersją byłoby:

if (!x) {
   //Undefined
}

Lub

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

Często robiłem:

function doSomething(variable)
{
    var undef;

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

The void operator zwraca undefined dla dowolnego argumentu/wyrażenia przekazanego do niego. możesz więc przetestować wynik (w rzeczywistości niektóre minifiery zmieniają kod z undefined na void 0, Aby zapisać kilka znaków)

Na przykład:

void 0
// undefined

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

Innym potencjalnym "rozwiązaniem" jest użycie obiektu window. Pozwala uniknąć problemu błędu odniesienia w przeglądarce.

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

Błąd mówi ci, że x Nawet nie istnieje! Nie została zadeklarowana , co różni się od tego, że przypisano wartość.

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

Jeśli zadeklarujesz x, nie dostaniesz błędu. Otrzymasz alert z napisem undefined, Ponieważ x istnieje/został zadeklarowany, ale nie przypisano mu wartości.

Aby sprawdzić, czy zmienna została zadeklarowana, możesz użyć typeof, każda inna metoda sprawdzania, czy zmienna istnieje, spowoduje ten sam błąd na początku.

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

Sprawdza typ wartości przechowywanej w x. Zwróci undefined tylko wtedy, gdy xnie zostało zadeklarowane lub jeśli zostało zadeklarowane i nie zostało jeszcze przypisane.

Można również użyć trójdzielnego operatora warunkowego:

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

Często używam najprostszego sposobu:

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

EDIT:

Bez inicjalizacji zmiennej zostanie wyrzucony wyjątek "Uncaught ReferenceError: zmienna nie jest zdefiniowana..."

Po prostu zrób coś takiego jak poniżej:

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

I nazwij to tak:

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

Możemy sprawdzić undefined w następujący sposób

var x; 

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

Przyjęta odpowiedź jest prawidłowa. Chciałem tylko dodać jeszcze jedną opcję. Możesz również użyć try ... catch block, aby poradzić sobie z tą sytuacją. Dziwaczny przykład:

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
}

Bądź świadomy catch bloku, który jest nieco bałagan, ponieważ tworzy Zakres na poziomie bloku. I oczywiście przykład jest niezwykle uproszczony, aby odpowiedzieć na zadane pytanie, nie obejmuje najlepszych praktyk w obsłudze błędów ;).

Używam małej funkcji, aby zweryfikować zadeklarowaną zmienną, co naprawdę zmniejsza ilość bałaganu w moich plikach javascript. Dodaję sprawdzenie wartości, aby upewnić się, że zmienna nie tylko istnieje, ale również została przypisana wartość. Drugi warunek sprawdza, czy zmienna również została utworzona, ponieważ jeśli zmienna została zdefiniowana, ale nie powstała (zobacz przykład poniżej), nadal będzie wyświetlać błąd, jeśli spróbujesz odwołać się do jej wartości w kodzie.

Nie utworzono instancji - var my_variable; Utworzono instancję - var my_variable = "";

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

Możesz następnie użyć instrukcji warunkowej, aby sprawdzić, czy zmienna została zarówno zdefiniowana, jak i utworzona w ten sposób...

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

Lub sprawdzić, czy nie zostało zdefiniowane i utworzone użycie...

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