Uważam, że istnieje wiele błędnych odpowiedzi na ten temat. Wbrew powszechnemu przekonaniu, "undefined" jest Nie słowem kluczowym w JavaScript i może w rzeczywistości mieć przypisaną wartość.

Poprawny Kod

Najbardziej solidnym sposobem wykonania tego testu jest:

if (typeof myVar === "undefined")

To zawsze zwróci poprawny wynik, a nawet obsłuży sytuację, w której myVar nie jest zadeklarowana.

Kod zdegenerowany. NIE UŻYWAĆ.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

Dodatkowo, myVar === undefined spowoduje błąd w sytuacji, gdy myVar jest niezgłoszony.

Pomimo tego, że jest gorąco polecany przez wiele innych odpowiedzi tutaj, typeof to zły wybór . Nigdy nie powinien być używany do sprawdzania, czy zmienne mają wartość undefined, ponieważ działa jako połączone sprawdzanie wartości undefined i czy zmienna istnieje. W zdecydowanej większości przypadków wiesz, kiedy zmienna istnieje, a typeof po prostu wprowadzi możliwość cichej awarii, jeśli popełnisz literówkę w nazwie zmiennej lub w dosłownym łańcuchu znaków 'undefined'.

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}

var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

Więc jeśli nie robisz feature detection2, gdzie nie ma pewności, czy dana nazwa będzie w zakresie (jak sprawdzanie typeof module !== 'undefined' jako krok w kodzie specyficznym dla środowiska CommonJS), typeof jest szkodliwym wyborem, gdy jest używana na zmiennej, a poprawną opcją jest bezpośrednie porównanie wartości:{[40]]}

var foo = …;

if (foo === undefined) {
    ⋮
}

Niektóre powszechne nieporozumienia na ten temat obejmują:

• Że odczytanie "niezainicjowanej" zmiennej (var foo) lub parametru (function bar(foo) { … }, nazywanego bar()) zawiedzie. Nie jest to po prostu prawda – zmienne bez jawnej inicjalizacji i parametry, które nie zostały podane wartości, zawsze stają się undefined i są zawsze w zakresie.

• To undefined można nadpisać. To prawda, że undefined nie jest słowem kluczowym, ale jest tylko do odczytu i nie można go konfigurować. Istnieją inne wbudowane, których prawdopodobnie nie unikasz, pomimo ich statusu niezwiązanego ze słowem kluczowym(Object, Math, NaN...) a praktyczny kod zazwyczaj nie jest napisany w aktywnie złośliwym środowisko, więc nie jest to dobry powód do zmartwień undefined. (Ale jeśli piszesz generator kodu, możesz użyć void 0.)

Z tym, jak zmienne działają na uboczu, nadszedł czas, aby rozwiązać rzeczywiste pytanie: właściwości obiektu. Nie ma powodu, aby kiedykolwiek używać typeof do Właściwości obiektu. Wcześniejszy wyjątek dotyczący wykrywania funkcji nie ma tutaj zastosowania - typeof ma tylko specjalne zachowanie na zmiennych i wyrażeniach, które odwołują się do Właściwości obiektu zmienne.

To:

if (typeof foo.bar === 'undefined') {
    ⋮
}

Jest zawsze dokładnie równoważne do tego3:

if (foo.bar === undefined) {
    ⋮
}

I biorąc pod uwagę powyższe rady, aby uniknąć mylenia czytelników co do tego, dlaczego używasz typeof, ponieważ najbardziej sensowne jest użycie === do sprawdzenia równości, ponieważ może to być refakturowane do sprawdzenia wartości zmiennej później, a ponieważ po prostu wygląda lepiej, powinieneś zawsze używać === undefined 3 również tutaj.

Coś innego do rozważenia, kiedy to jeśli chodzi o właściwości obiektu, to czy naprawdę chcesz w ogóle sprawdzić undefined. Dana nazwa właściwości może być nieobecna na obiekcie (wytwarzającym wartość undefined podczas odczytu), obecna na samym obiekcie z wartością undefined, obecna na prototypie obiektu z wartością undefined lub obecna na jednym z tych z wartością Nie-undefined. 'key' in obj powie Ci, czy klucz znajduje się w dowolnym miejscu w łańcuchu prototypów obiektu, a Object.prototype.hasOwnProperty.call(obj, 'key') powie Ci, czy znajduje się bezpośrednio na obiekcie. Nie będę wdawać się w szczegóły w ta odpowiedź na temat prototypów i używania obiektów jako map z kluczem ciągowym, ponieważ głównie ma na celu przeciwdziałanie wszystkim złym Radom w innych odpowiedziach, niezależnie od możliwych interpretacji pierwotnego pytania. Czytaj na prototypy obiektów na MDN więcej!

_{1 nietypowy wybór przykładowej nazwy zmiennej? jest to prawdziwy martwy kod z rozszerzenia NoScript dla Firefoksa.
2 nie zakładaj, że nie wiedząc, co jest w zasięgu jest w porządku w ogóle, chociaż. bonus Luka spowodowana nadużyciem zakresu dynamicznego: Project Zero 1225
3 po raz kolejny zakładając środowisko ES5+ i że undefined odnosi się do właściwości undefined obiektu globalnego.}

W JavaScript występuje null oraz undefined . Mają różne znaczenia.

• undefined oznacza, że wartość zmiennej nie została zdefiniowana; nie wiadomo, jaka jest wartość.
• null oznacza, że wartość zmiennej jest zdefiniowana i ustawiona na null (nie ma wartości).

Istnieje również podobny wartość, null, której znaczenie to "ta wartość jest zdefiniowana, ale nie ma wartości". Różnica w znaczeniu między undefined a null jest głównie akademicka i zazwyczaj niezbyt interesująca. w programach praktycznych często konieczne jest sprawdzenie, czy coś "ma wartość". W takich przypadkach można użyć wyrażenia something == undefined, ponieważ, mimo że nie są one dokładnie tą samą wartością, null = = undefined wytworzy true.

Więc, myślę, że najlepszym sposobem na sprawdź, czy coś nie było niezdefiniowane:

if (something == undefined)

Właściwości obiektu powinny działać w ten sam sposób.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

Co to znaczy: "undefined object property" ?

var o = { a: undefined }

Czy o.a jest niezdefiniowany? Tak! Jego wartość jest nieokreślona. Czy o.b jest niezdefiniowany? Jasne! Nie ma własności "b" w ogóle! Ok, zobacz teraz jak zachowują się różne podejścia w obie sytuacje:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

Widzimy wyraźnie, że typeof obj.prop == 'undefined' i obj.prop === undefined są równoważne i nie rozróżniają tych różnych sytuacji. And 'prop' in obj może wykryć sytuację, gdy właściwość nie została zdefiniowana w ogóle i nie zwraca uwagi na wartość właściwości, która może być niezdefiniowana.

1) chcesz wiedzieć, czy właściwość jest niezdefiniowana przez pierwsze lub drugie znaczenie (najbardziej typowa sytuacja).

obj.prop === undefined // IMHO, see "final fight" below

2) chcesz po prostu wiedzieć, czy obiekt ma jakąś właściwość i nie obchodzi go jego wartość.

'prop' in obj

Uwagi:

• nie można jednocześnie sprawdzać obiektu i jego właściwości. Na przykład, to x.a === undefined lub to typeof x.a == 'undefined' podnosi ReferenceError: x is not defined, Jeśli x nie jest zdefiniowane.
• zmienna undefined jest zmienną globalną (tak naprawdę jest to window.undefined w przeglądarkach). Jest on obsługiwany od wersji 1. ECMAScript, a od wersji 5 jest to tylko do odczytu. Więc w nowoczesnych przeglądarkach nie można [[30]] przedefiniować do prawda jak wielu autorów lubi nas straszyć, ale nadal jest to prawdą dla starszych przeglądarek.

Final fight: obj.prop === undefined vs typeof obj.prop == 'undefined'

Plusy z obj.prop === undefined:

Jest trochę krótszy i wygląda ładniej]}
• silnik JavaScript wyświetli błąd, jeśli źle napisałeś undefined

Minusy z obj.prop === undefined:

• Może być nadpisywany w starych przeglądarkach]}

Plusy z typeof obj.prop == 'undefined':

• to naprawdę universal! Działa w nowych i starych przeglądarkach.

Minusy z typeof obj.prop == 'undefined':

• 'undefned' (błędny zapis ) tutaj jest tylko ciąg stały, więc silnik JavaScript nie może pomóc, jeśli masz błędnie go jak ja właśnie zrobił.

Węzeł.js obsługuje zmienną globalną undefined jako global.undefined (może być również używana bez prefiksu 'global'). Nie znam się na innych implementacjach JavaScript po stronie serwera.

Problem sprowadza się do trzech przypadków:

1. obiekt posiada właściwość, a jego wartością nie jest undefined.
2. obiekt posiada właściwość, a jego wartością jest undefined.
3. obiekt nie posiada właściwości.

To mówi nam coś, co uważam za ważne:

Istnieje różnica między niezdefiniowanym członkiem a zdefiniowanym członkiem o niezdefiniowanej wartości.

Ale nieszczęśliwie typeof obj.foo nie mówi nam, który z trzech przypadków my mam. Możemy jednak połączyć to z "foo" in obj, aby rozróżnić przypadki.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

Warto zauważyć, że te testy są takie same dla null również

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

Argumentowałbym, że w niektórych przypadkach bardziej sensowne (i jaśniejsze) jest sprawdzanie, czy właściwość istnieje, niż sprawdzanie, czy jest niezdefiniowana, a jedynym przypadkiem, w którym to sprawdzanie będzie inne, jest przypadek 2, rzadki przypadek rzeczywistego wpisu w obiekcie o niezdefiniowanej wartości.

Na przykład: właśnie byłem refaktoryzacja kodu, który miał kilka sprawdzeń, czy obiekt ma daną właściwość.

if( typeof blob.x != 'undefined' ) {  fn(blob.x); }

Co było jaśniejsze, gdy pisano bez sprawdzania na niezdefiniowany.

if( "x" in blob ) { fn(blob.x); }

Ale jak już wspomniano, nie są one dokładnie takie same (ale są wystarczająco dobre dla moich potrzeb).

if ( typeof( something ) == "undefined") 

Nie jestem pewien, skąd wzięło się pochodzenie używania === z typeof i jako Konwencja widzę, że jest ono używane w wielu bibliotekach, ale operator typeof zwraca literal Łańcuchowy, i wiemy to z góry, więc dlaczego chcesz również wpisać check it too?

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

Crossposting moja odpowiedź z pytania pokrewnego Jak mogę sprawdzić "undefined" w JavaScript?.

specyficzne dla tego pytania, patrz przypadki testowe z someObject.<whatever>.

Niektóre scenariusze ilustrujące wyniki różnych odpowiedzi: http://jsfiddle.net/drzaus/UVjM4/

(zauważ, że użycie var do testów in robi różnicę, gdy w opakowaniu z lunetą)

Kod odniesienia:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

Oraz wyniki:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

If you do

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

Nie powiedzie się, gdy zmienna myvar nie istnieje, ponieważ myvar nie jest zdefiniowany, więc skrypt jest uszkodzony i test nie ma żadnego efektu.

Ponieważ obiekt window ma globalny zasięg (obiekt domyślny) poza funkcją, deklaracja zostanie 'dołączona' do obiektu window.

Na przykład:

var myvar = 'test';

Zmienna globalna myvar jest taka sama jak window.myvar lub okno ['myvar']

To unikaj błędów w testowaniu, gdy zmienna globalna istnieje, lepiej Użyj:

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

Pytanie, czy zmienna rzeczywiście istnieje, nie ma znaczenia, jej wartość jest nieprawidłowa. W przeciwnym razie inicjalizacja zmiennych z undefined jest głupotą i lepiej jest użyć wartości false do inicjalizacji. Gdy wiesz, że wszystkie zadeklarowane zmienne są inicjalizowane false, możesz po prostu sprawdzić ich typ lub polegać na !window.myvar, aby sprawdzić, czy ma ona właściwą/poprawną wartość. Więc nawet jeśli zmienna nie jest zdefiniowana to !window.myvar jest to samo dla myvar = undefined lub myvar = false lub myvar = 0.

Jeśli spodziewasz się określonego typu, przetestuj typ zmiennej. Aby przyspieszyć testowanie warunku, lepiej zrób:

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

Gdy pierwszy i prosty warunek jest prawdziwy, interpreter pomija kolejne testy.

Jest zawsze lepiej użyć instancji / obiektu zmiennej, aby sprawdzić, czy ma prawidłową wartość. Jest bardziej stabilny i jest lepszym sposobem programowania.

(y)

Nie widziałem (mam nadzieję, że nie przegapiłem) nikogo sprawdzającego obiekt przed nieruchomością. Jest to więc Najkrótsza i najskuteczniejsza (choć niekoniecznie najbardziej klarowna):

if (obj && obj.prop) {
  // Do something;
}

Jeśli obj lub obj.prop jest undefined, null lub "falsy", Instrukcja if nie wykona bloku kodu. Jest to zwykle pożądane zachowanie w większości poleceń blokowych kodu (w JavaScript).

W artykule odkrywanie Otchłani Null i Undefined w JavaScript czytałem, że frameworki jak podkreślają.JS Użyj tej funkcji:

function isUndefined(obj){
    return obj === void 0;
}

Po prostu wszystko nie jest zdefiniowane w JavaScript, jest niezdefiniowane , nie ma znaczenia, czy jest to właściwość wewnątrz obiektu / tablicy czy tylko zwykła zmienna...

JavaScript posiada typeof, które sprawiają, że bardzo łatwo jest wykryć niezdefiniowaną zmienną.

Po prostu sprawdź, czy typeof whatever === 'undefined' zwróci wartość logiczną.

Tak zapisuje się słynną funkcjęisUndefined() w AngularJs V. 1x:

function isUndefined(value) {return typeof value === 'undefined';} 

Tak jak widzisz funkcja otrzymuje wartość, jeśli ta wartość jest zdefiniowany, zwróci false, w przeciwnym razie dla niezdefiniowanych wartości zwróci true.

Przyjrzyjmy się więc, jakie będą wyniki, gdy przekażemy wartości, w tym właściwości obiektu, jak poniżej, Oto lista zmiennych, które mamy:

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

I sprawdzamy je jak poniżej, możesz zobaczyć wyniki przed nimi jako komentarz:

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

Jak widzisz możemy sprawdzić wszystko używając czegoś takiego w naszym kodzie, jak wspomniano możesz po prostu użyć typeof w swoim kodzie, ale jeśli używasz go w kółko, Utwórz funkcję taką jak próbka kątowa, którą udostępniam i używaj ponownie zgodnie z suchym wzorem kodu.

Jeszcze jedno, aby sprawdzić właściwość obiektu w rzeczywistej aplikacji, której nawet obiekt nie istnieje, sprawdź najpierw, czy obiekt istnieje.

Jeśli zaznaczysz właściwość obiektu, a obiekt nie istnieje, wyrzuci błąd i zatrzyma działanie całej aplikacji.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

Tak proste, że można zawiń wewnątrz instrukcji if jak poniżej:

if(typeof x !== 'undefined') {
  //do something
}

Które również jest równe w kątowym 1.x...

function isDefined(value) {return typeof value !== 'undefined';}

Również inne frameworki javascript, takie jak underscore, mają podobne sprawdzanie definiowania, ale zalecam użycie typeof, jeśli nie używasz już żadnych frameworków.

Dodaję również sekcję z MDN, która zawiera przydatne informacje o typeof, undefined i void (0).

Równość ścisła i nieokreślona
możesz użyć undefined i operatory ścisłe równości i nierówności do ustalenia, czy zmienna ma wartość. W poniższym kodzie zmienna x nie jest zdefiniowana, a if statement evaluates to true.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

Uwaga: Operator ścisłej równości zamiast standardowej równości operator musi być tutaj użyty, ponieważ x = = undefined sprawdza również, czy x jest null, natomiast ścisła równość nie. null nie jest równoznaczne z undefined. Zobacz operatory porównania dla szczegóły.

Typeof operator and undefined
Alternatywnie można użyć typeof:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

Jednym z powodów użycia typeof jest to, że nie powoduje błędu, jeśli zmienna nie została zadeklarowana.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

Należy jednak unikać tego rodzaju techniki. JavaScript to język statycznie skalowany, więc wiedząc, czy dana zmienna jest zadeklarowana, można być odczytane przez sprawdzenie, czy jest zadeklarowana w / align = "left" / Na jedynym wyjątkiem jest zasięg globalny, ale zasięg globalny jest związany z obiekt globalny, więc sprawdzanie istnienia zmiennej w kontekst globalny można zrobić sprawdzając istnienie właściwości na obiekt globalny (na przykład za pomocą operatora in).

Operator Void i undefined

Operator void jest trzecią alternatywą.

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

Więcej > tutaj

'if (window.x) { } ' is error safe

Najprawdopodobniej chcesz if (window.x). To sprawdzenie jest bezpieczne nawet jeśli x nie został zadeklarowany (var x;) - przeglądarka nie wyświetla błędu.

Przykład: Chcę wiedzieć, czy moja przeglądarka obsługuje History API

if (window.history) {
    history.call_some_function();
}

Jak to działa:

Window jest obiektem, który przechowuje wszystkie zmienne globalne jako swoje członkowie i jest legalne próbować uzyskać dostęp do nieistniejącego członka. If x hasn 't been declarated or hasn' t been set then window.x zwraca undefined. undefined prowadzi do false kiedy if () ocenia to.

Czytając to, dziwię się, że tego nie widziałem. Znalazłem wiele algorytmów, które by do tego pasowały.

Nigdy Nie Zdefiniowano

Jeśli wartość obiektu nigdy nie została zdefiniowana, uniemożliwi to zwrócenie true, jeśli jest zdefiniowana jako null lub undefined. Jest to pomocne, jeśli chcesz, aby zwracana była wartość true dla wartości ustawionych jako undefined

if(obj.prop === void 0) console.log("The value has never been defined");

Zdefiniowany jako niezdefiniowany lub nigdy zdefiniowany

Jeśli chcesz, aby wynik był true dla wartości zdefiniowanych wartością undefined, lub nigdy nie zdefiniowany, możesz po prostu użyć === undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

Zdefiniowana jako wartość falsy, niezdefiniowana,null lub nigdy nie zdefiniowana.

Powszechnie, ludzie prosili mnie o algorytm, aby dowiedzieć się, czy wartość jest falsy, undefined, lub null. Następujące prace.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

"propertyName" in obj //-> true | false

Rozwiązanie jest nieprawidłowe. W JavaScript,

null == undefined

Zwróci true, ponieważ oba są "rzucone" do logiki logicznej i są fałszywe. Poprawnym sposobem byłoby sprawdzenie

if (something === undefined)

Który jest operatorem tożsamości...

Porównaj z void 0, dla terseness.

if (foo !== void 0)

To nie jest tak gadatliwe jak if (typeof foo !== 'undefined')

Możesz uzyskać tablicę niezdefiniowaną z path używając poniższego kodu.

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

Jsfiddle link

ECMAScript 10 wprowadził nową funkcję- opcjonalne łańcuchowanie, której można użyć do użycia właściwości obiektu tylko wtedy, gdy obiekt jest zdefiniowany w następujący sposób:

const userPhone = user?.contactDetails?.phone;

Będzie odwoływać się do właściwości phone tylko wtedy, gdy zdefiniowane są user i contactDetails.

Ref. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

Istnieje ładny i elegancki sposób, aby przypisać zdefiniowaną właściwość do nowej zmiennej, jeśli jest zdefiniowana, lub przypisać jej domyślną wartość jako rezerwową, jeśli jest niezdefiniowana.

var a = obj.prop || defaultValue;

Jest to odpowiednie, jeśli masz funkcję, która otrzymuje dodatkową właściwość konfiguracyjną:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);
}

Teraz wykonuję

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

Wszystkie odpowiedzi są niekompletne. Jest to właściwy sposób poznania, że istnieje właściwość "zdefiniowana jako niezdefiniowana":

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined'));
};

Przykład:

var a = { b : 1, e : null };
a.c = a.d;

hasUndefinedProperty(a, 'b'); // false: b is defined as 1
hasUndefinedProperty(a, 'c'); // true: c is defined as undefined
hasUndefinedProperty(a, 'd'); // false: d is undefined
hasUndefinedProperty(a, 'e'); // false: e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c'); // false: c is undefined

Szkoda, że to była właściwa odpowiedź i jest zakopana w złych odpowiedziach >_ Więc dla każdego, kto przejedzie, dam ci undefined ' s za darmo!!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

Oto moja sytuacja:

Używam wyniku wywołania REST. Wynik powinien być parsowany z JSON do obiektu JavaScript.

Podczas korzystania z tego postu, aby pomóc mi bronić się przed tym, próbowałem tego:

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

Dla mojej sytuacji, jeśli się zrestresuje.danych[0] = = = "obiekt", wtedy mogę bezpiecznie zacznij sprawdzać resztę członków. If undefined then throw the error as above.

Chodzi mi o to, że w mojej sytuacji wszystkie poprzednie sugestie w tym poście nie zadziałały. Nie mówię, że mam rację i wszyscy się mylą. W ogóle nie jestem mistrzem JavaScript, ale mam nadzieję, że to komuś pomoże.

Przeglądając komentarze, dla tych, którzy chcą sprawdzić, czy jest niezdefiniowany lub jego wartość jest null:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

Jeśli używasz biblioteki jQuery to jQuery.isEmptyObject() Wystarczy w obu przypadkach,

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

Jeśli używasz Angular:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Podkreślenie.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

Podaję tutaj trzy sposoby dla tych, którzy oczekują dziwnych odpowiedzi:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}

function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}

function isUndefined3(val) {
    const defaultVal = {};
    return ((input = defaultVal) => input === defaultVal)(val);
}

function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

IsUndefined1:

Spróbuj pobrać właściwość wartości wejściowej i sprawdź komunikat o błędzie, czy istnieje. Jeśli wartość wejściowa jest niezdefiniowana, komunikat o błędzie to Uncaught TypeError: Cannot read property ' b ' of undefined.

IsUndefined2:

Przekonwertuj wartość wejściową na ciąg znaków, aby porównać z "undefined" i upewnij się, że jest ujemna wartość.

IsUndefined3:

W JavaScript parametr opcjonalny działa, gdy wartością wejściową jest dokładnie undefined.

Używam if (this.variable), aby sprawdzić, czy jest zdefiniowana. Prosty if (variable), polecane w poprzedniej odpowiedzi , nie dla mnie.

Okazuje się, że działa tylko wtedy, gdy zmienna jest polem jakiegoś obiektu, obj.someField aby sprawdzić, czy jest zdefiniowana w słowniku. Ale możemy użyć this lub window jako obiektu słownika, ponieważ Dowolna zmienna jest polem w bieżącym oknie, jak to Rozumiem. Dlatego tutaj jest test:

if (this.abc) 
    alert("defined"); 
else 
    alert("undefined");

abc = "abc";
if (this.abc) 
    alert("defined"); 
else 
    alert("undefined");

Najpierw wykrywa, że zmienna {[6] } jest niezdefiniowana i jest on zdefiniowany po inicjalizacji.

Jest bardzo łatwy i prosty sposób.

Możesz użyć opcjonalnego łańcucha:

x = {prop:{name:"sajad"}}

console.log(x.prop?.name) // Output is: "sajad"
console.log(x.prop?.lastName) // Output is: undefined

Lub

if(x.prop?.lastName) // The result of this 'if' statement is false and is not throwing an error

Możesz używać opcjonalnego łączenia łańcuchowego nawet dla funkcji lub tablic.

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

Zwraca false, jeśli zmienna jest ustawiona, a true, jeśli jest niezdefiniowana.

Następnie użyj:

if (isUnset(var)) {
  // initialize variable here
}

Chciałbym pokazać ci coś, czego używam w celu ochrony zmiennej undefined:

Object.defineProperty(window, 'undefined', {});

Zakazuje to każdemu zmiany wartości window.undefined, tym samym niszcząc kod oparty na tej zmiennej. Jeśli użyjesz "use strict", wszystko, co próbuje zmienić jego wartość, zakończy się błędem, w przeciwnym razie zostanie zignorowane po cichu.