Chcesz typeof operator . Konkretnie:

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

W JavaScript zmienna może być zdefiniowana, ale posiada wartość undefined, więc najczęstsza odpowiedź nie jest poprawna technicznie, a zamiast tego wykonuje następujące czynności:

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
}

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

To oczywiście zakłada, że uruchamiasz się w przeglądarce (gdzie window jest nazwą globalnej obiekt). Ale jeśli kręcisz się z takimi globalami, prawdopodobnie jesteś w przeglądarce. Subiektywnie używanie 'name' in window jest stylistycznie zgodne z używaniem window.name w odniesieniu do globali. Dostęp do globali jako właściwości window zamiast jako zmiennych pozwala zminimalizować liczbę nierejestrowanych zmiennych, do których odwołujesz się w kodzie (na korzyść lintingu), i pozwala uniknąć możliwości, że global zostanie zasłonięty przez zmienną lokalną. Również, jeśli globale sprawiają, że Twoja skóra pełznie, możesz poczuć wygodniejsze dotykanie ich tylko tym relatywnie długim kijem.

W większości przypadków można by użyć:

elem != null

W przeciwieństwie do prostej if (elem), pozwala 0, false, NaN i '', ale odrzuca null lub undefined, co czyni go dobrym, ogólnym testem na obecność argumentu lub właściwości obiektu.

Inne kontrole również nie są nieprawidłowe, po prostu mają różne zastosowania:

• if (elem): może być stosowany, jeśli elem jest gwarantowany jako obiekt, lub jeśli false, 0, itd. są uważane za" domyślne " wartości (stąd równoważne undefined lub null).

• typeof elem == 'undefined' Może być stosowany w przypadkach, gdy określona null ma odrębne znaczenie dla niezainicjowanej zmiennej lub właściwości.

  • jest to jedyne sprawdzenie, które nie wyrzuci błędu , jeśli elemnie jest zadeklarowane (tzn. nie jest deklaracją var, Nie jest właściwością window, ani argumentem funkcji). Jest to, moim zdaniem, dość niebezpieczne, ponieważ pozwala literówki prześlizgnąć się niezauważone. Aby tego uniknąć, zobacz poniżej metoda.

Przydatne jest również ścisłe porównanie z undefined:

if (elem === undefined) ...

Jednak, ponieważ globalna undefined może być nadpisana inną wartością, najlepiej jest zadeklarować zmienną undefined w bieżącym zakresie przed jej użyciem:

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

Lub:

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

Dodatkową zaletą tej metody jest to, że minifigurki JS mogą zredukować zmienną undefined do pojedynczego znaku, zapisując za każdym razem kilka bajtów.

W wielu przypadkach, używając:

if (elem) { // or !elem

Zrobi to za Ciebie!... to sprawdzi poniższe przypadki:

1. undefined: Jeśli wartość nie jest zdefiniowana i wynosi undefined
2. null: jeśli jest null, na przykład, jeśli element DOM nie istnieje...
3. pusty łańcuch: ''
4. 0: Liczba zero
5. NaN: nie Liczba
6. false

Więc to pokryje wszystko przypadki, ale zawsze są dziwne przypadki, które chcielibyśmy również zakryć, na przykład łańcuch ze spacjami, taki jak ten ' ', który będzie zdefiniowany w javascript, ponieważ ma spacje wewnątrz łańcucha... na przykład w tym przypadku dodajesz jeszcze jedno sprawdzenie za pomocą trim (), jak:

if(elem) {

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

Te kontrole dotyczą tylko wartości , ponieważ obiekty i tablice działają inaczej w Javascript, pusta tablica [] i pusty obiekt {}są zawsze true.

Tworzę poniższy obrazek aby pokazać krótki Skrót odpowiedzi:

Jak sprawdzić czy zmienna istnieje

Jest to dość kuloodporne rozwiązanie do testowania, czy zmienna istnieje i została zainicjalizowana:

var setOrNot = typeof variable !== typeof undefined;

Jest najczęściej używany w połączeniu z operatorem trójkowym do ustawienia domyślnego w przypadku, gdy pewna zmienna nie została zainicjowana:

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

Problemy z enkapsulacją

Niestety, nie można po prostu zamknąć czeku w funkcji.

Możesz pomyśleć o zrobieniu coś takiego:

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

Jednak spowoduje to błąd Odniesienia, jeśli wywołujesz eg. isset(foo) i zmienna foo nie została zdefiniowana, ponieważ nie można przekazać nieistniejącej zmiennej do funkcji:

Uncaught ReferenceError: foo nie jest zdefiniowane

Sprawdzanie, czy parametry funkcji są niezdefiniowane

Podczas gdy nasza isset funkcja nie może być użyta do sprawdzenia czy zmienna istnieje czy nie (z powodów wyjaśnionych tutaj), pozwala nam to sprawdzić, czy parametry funkcji są niezdefiniowane:

var a = '5';

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

test(a);

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

Mimo że żadna wartość dla {[7] } nie jest przekazywana do funkcji test, nasza funkcja isset działa doskonale w tym kontekście, ponieważ y jest znana w funkcji test jako wartość undefined.

Sprawdź, czy obiekthasOwnProperty()

Alternatywą dla mnóstwa odpowiedzi typeof jest użycie hasOwnProperty(), które oczywiście sprawdza, czy obiekt (prawie wszystko w JS) ma właściwość tj. zmienną (między innymi).

Metoda hasOwnProperty() Zwraca wartość logiczną wskazującą, czy obiekt posiada określoną właściwość jako własną (Nie dziedziczoną) właściwość.

Każdy obiekt pochodzący z Object dziedziczy metodę hasOwnProperty(). Metoda ta może być użyta do określenia, czy obiekt ma określoną właściwość jako bezpośrednią właściwość tego obiektu; w przeciwieństwie do operatora w operatorze, metoda ta nie sprawdza łańcucha prototypów obiektu.

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

Najlepsze w hasOwnProperty() jest to, że podczas jej wywoływania nie używamy zmiennej, która może być jeszcze niezdefiniowana - co oczywiście stanowi połowę problemu.

Chociaż nie zawsze doskonały lub idealne rozwiązanie, w pewnych okolicznościach, to tylko praca!

Istnieje inny krótki ręczny sposób, aby to sprawdzić, gdy wykonujesz proste zadania i powiązane kontrole. Po prostu użyj Operator warunkowy (trójdzielny).

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

Również to będzie pomocne, gdy spróbujesz zadeklarować zmienną globalną z przypisaniem instancji zmiennej referencyjnej.

Jeśli chcesz sprawdzić zmienną nie powinno być undefined lub null. Następnie wykonaj poniższe sprawdzenie.

Kiedy zmienna jest zadeklarowana, i jeśli chcesz sprawdzić wartość, jest to nawet proste: i będzie wykonywać undefined i null kontrole razem.

var values = variable ? variable : '';

Undefined,boolean, string, number, function

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

}

Obiekt, Tablica

if( foo instanceof Array ) { 

}

To zależy, czy zależy Ci tylko na tym, że zmienna została zdefiniowana lub czy chcesz, aby miała sensowną wartość.

Sprawdzenie, czy typ jest niezdefiniowany, sprawdzi, czy zmienna została jeszcze zdefiniowana.

=== null or !== null sprawdzi tylko, czy wartość zmiennej jest dokładnie null.

== null lub != null sprawdzi, czy wartość to undefined lub null.

if(value) sprawdzi czy zmienna jest undefined, null, 0, albo pusty ciąg.

Najwyższa odpowiedź jest prawidłowa, użyj typeof.

Chciałem jednak podkreślić, że w JavaScript {[0] } jest zmienny (z jakiegoś bezbożnego powodu). Więc samo sprawdzanie varName !== undefined może nie zawsze wrócić tak, jak tego oczekujesz, ponieważ inne biblioteki mogły zmienić undefined. Kilka odpowiedzi (na przykład @ skalee), wydaje się, że wolą nie używać typeof, a to może sprawić, że jedna wpadnie w kłopoty.

"starym" sposobem radzenia sobie z tym było zadeklarowanie undefined jako var, aby zrównoważyć wszelkie potencjalny muting / over-riding Of undefined. Jednak najlepszym sposobem jest użycie typeof, ponieważ zignoruje ono wszelkie nadpisanie undefined z innego kodu. Zwłaszcza jeśli piszesz kod do użytku w dziczy, gdzie kto wie, co jeszcze może działać na stronie...

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

Or better

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

Działa we wszystkich przeglądarkach

Aby przyczynić się do dyskusji, Jeśli wiem, że zmienna powinna być ciągiem znaków lub obiektem, zawsze wolę if (!variable), więc sprawdzam, czy jest fałszywa. Może to doprowadzić do bardziej czystego kodu tak, że na przykład:

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

..może być zredukowana do:

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

Trudno jest odróżnić undefined od null. Null jest wartością, którą możesz przypisać do zmiennej, gdy chcesz wskazać, że zmienna nie ma określonej wartości. Undefined jest wartością specjalną, która będzie wartością domyślną nieprzypisanych zmiennych.

var _undefined;
var _null = null;

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

Null jest wartością w JavaScript i typeof null zwraca "object"

Dlatego zaakceptowana odpowiedź nie będzie działać, jeśli przekażesz wartości null. Jeśli przekazujesz wartości null, musisz dodać dodatkowe sprawdzenie wartości null:

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

Te odpowiedzi (oprócz rozwiązania Freda Gandta) są niepoprawne lub niekompletne.

Załóżmy, że mój variableName; musi mieć wartość undefined, a zatem została zadeklarowana w sposób taki jak var variableName;, co oznacza, że jest jużzainicjalizowana ; - Jak sprawdzić, czy jest już zadeklarowana?

Lub nawet lepiej-jak od razu sprawdzić, czy "Book1.Rozdział 22.paragraph37 " istnieje z jednym wywołaniem, ale nie podnieść błąd odniesienia?

Robimy to używając najbardziej potężny Operator JasvaScript, operator in.:

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

W czasach szczytowej popularności AJAX napisałem metodę (nazwaną później) isNS (), która jest w stanie określić, czy przestrzeń nazw istnieje, w tym głębokie testy nazw właściwości, takich jak "Book1.Rozdział 22.paragraph37 " i wiele więcej.

Ale ponieważ został on wcześniej opublikowany i ze względu na jego duże znaczenie zasługuje na opublikowanie w osobnym wątku Nie będę go tutaj zamieszczać, ale podam słowa kluczowe ( javascript + isNS ), które pomogą Ci zlokalizować kod źródłowy, poparty wszystkimi niezbędnymi wyjaśnieniami.

Najbardziej wytrzymałe' is it defined ' sprawdzanie jest z typeof

if (typeof elem === 'undefined')

Jeśli tylko sprawdzasz zdefiniowaną zmienną, aby przypisać domyślną, łatwą do odczytania jedną linijkę często można to zrobić:

elem = elem || defaultElem;

Często można go używać, Zobacz: Idiomatyczny sposób ustawiania wartości domyślnej w javascript

Istnieje również jedna linijka używająca słowa kluczowego typeof:

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

Możesz użyć operatora typeof.

Na przykład,

var dataSet;

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

Powyższy fragment kodu zwróci wyjście jak

Zmienna dataSet jest: undefined.

W szczególnej sytuacji opisanej w pytaniu,

typeof window.console === "undefined"

Jest identyczne z

window.console === undefined

Należy pamiętać, że szukamy console tylko w zasięgu globalnym (który jest obiektem window we wszystkich przeglądarkach). W tej konkretnej sytuacji jest to pożądane. Nie chcemy console definiować gdzie indziej.

Moje preferencje to typeof(elem) != 'undefined' && elem != null.

Jakkolwiek wybierzesz, rozważ umieszczenie czeku w takiej funkcji

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

Jeśli nie wiesz, że zmienna jest zadeklarowana, kontynuuj przez typeof (x) != 'undefined' && x != null;

Jeśli wiesz, że zmienna jest zadeklarowana, ale może nie być existy, możesz użyć

existy(elem) && doSomething(elem);

Zmienna, którą sprawdzasz, może być czasami zagnieżdżoną właściwością. Możesz użyć prop / / {}, aby przejść w dół linii sprawdzającej istnienie danej właściwości:

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

Po każdym korzystanie z nieruchomości (...' || {}').nextProp, aby brakująca właściwość nie wywołała błędu.

Lub możesz użyć existy jak existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Jeśli chcesz, aby zdefiniowany blok coś zrobił, użyj tego

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

Jeśli chcesz, aby undefined block coś zrobił lub przypisał lub zdefiniował zmienną, użyj tego

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

Używam dwóch różnych sposobów w zależności od obiektu.

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

Czasami nie chcę oceniać pustego ciągu jako false, więc używam tego przypadku

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

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

Jeśli potrzebujesz czegoś odwrotnego, to w pierwszej kolejności !zmienna staje się !!zmienną, a w nieprawidłowej funkcji = = = become != i nazwy funkcji zmieniają się na notInvalid.

To zależy od sytuacji. Jeśli sprawdzasz coś, co może lub nie zostało zdefiniowane globalnie poza twoim kodem (np. jQuery), chcesz:

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

(nie ma potrzeby ścisłej równości, typeof zawsze zwraca łańcuch znaków.) Ale jeśli masz argumenty do funkcji, które mogły lub nie zostały przekazane, zawsze będą zdefiniowane, ale null jeśli zostaną pominięte.

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

Nieco bardziej funkcjonalny i łatwy w użyciu:

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

Funkcja zwróci prawda if exist, else fałsz jeśli nie istnieje.

A co z prostym:

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

Pamiętaj o tym, gdy sprawdzasz != = or != przeciw "undefined" nie zadziała

testowane na Firfox Quantom 60.0.1

Użyj tego testu zamiast tego, aby uniknąć konfliktu

if(!(typeof varibl['fl'] === 'undefined')) {

            console.log(varibl['fl']);
            console.log("Variable is Defined");
        }else{

            console.log(varibl['fl']);
            console.log("Variable is Un-Defined");
        }

Aby sprawdzić, czy zmienna została zadeklarowana/ustawiona, zrobiłem tę brudną sztuczkę.

Nie znalazłem sposobu na wyodrębnienie kodu do funkcji, nawet z 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");
}

Nie widzę tego w powyższych odpowiedziach, więc zasugeruję to tutaj, tak myślę.

function isDefined(x) { return !!x }

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

!x zwróci true iff X jest albo null lub undefined , więc !!x zwróci tylko true iff X nie jest undefined ani null.

zdaję sobie sprawę, że to również odpowiada za przypadek zerowy, ale oto uczciwe ostrzeżenie o tym.