Erkennen einer undefinierten Objekteigenschaft

Question

Wie kann man am besten überprüfen, ob eine Objekteigenschaft in JavaScript undefiniert ist?

Answer 1

Das Problem lässt sich auf drei Fälle reduzieren:

1. Das Objekt hat die Eigenschaft und ihr Wert ist nicht undefined .
2. Das Objekt hat die Eigenschaft und ihr Wert ist undefined .
3. Das Objekt hat die Eigenschaft nicht.

Dies sagt uns etwas, das ich für wichtig halte:

Es gibt einen Unterschied zwischen einem undefinierten Mitglied und einem definierten Mitglied mit einem undefinierten Wert.

Aber unglücklicherweise typeof obj.foo sagt uns nicht, um welchen der drei Fälle es sich handelt. Wir können dies jedoch kombinieren mit "foo" in obj um die Fälle zu unterscheiden.

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

Es sei darauf hingewiesen, dass diese Tests für folgende Bereiche identisch sind null Einträge zu

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

Ich würde argumentieren, dass es in manchen Fällen sinnvoller (und klarer) ist, zu prüfen, ob die Eigenschaft vorhanden ist, als zu prüfen, ob sie undefiniert ist, und der einzige Fall, in dem diese Prüfung anders ausfällt, ist Fall 2, der seltene Fall eines tatsächlichen Eintrags im Objekt mit einem undefinierten Wert.

Zum Beispiel: Ich habe gerade eine Reihe von Code überarbeitet, der eine Reihe von Prüfungen enthielt, ob ein Objekt eine bestimmte Eigenschaft hat.

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

Das war klarer, als es ohne eine Prüfung auf undefiniert geschrieben wurde.

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

Aber wie bereits erwähnt, sind diese nicht genau dasselbe (aber für meine Bedürfnisse mehr als ausreichend).

Answer 2

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

Bei mir hat das funktioniert, bei den anderen nicht.

Answer 3

Ich bin mir nicht sicher, woher die Verwendung von === con typeof stammt und als Konvention in vielen Bibliotheken verwendet wird, aber der typeof-Operator gibt ein Zeichenkettenliteral zurück, und das wissen wir im Voraus, warum sollte man es also auch noch typisieren wollen?

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

Answer 4

Ich habe nicht gesehen (ich hoffe, ich habe es nicht verpasst), dass jemand das Objekt vor der Eigenschaft überprüft hat. Dies ist also der kürzeste und effektivste Weg (wenn auch nicht unbedingt der klarste):

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

Wenn obj oder obj.prop undefiniert, null oder "falsy" ist, wird die if-Anweisung den Codeblock nicht ausführen. Dies ist in der Regel das gewünschte Verhalten in den meisten Codeblock-Anweisungen (in JavaScript).

UPDATE: (7/2/2021)

In der neuesten Version von JavaScript gibt es einen neuen Operator für optionale Verkettung: ?.

Dies ist wahrscheinlich die expliziteste und effizienteste Methode, um das Vorhandensein von Objekteigenschaften in Zukunft zu überprüfen.

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

Answer 5

Querverschiebung meine Antwort aus verwandter Frage Wie kann ich in JavaScript auf "undefiniert" prüfen? .

Speziell zu dieser Frage, siehe Testfälle mit someObject.<whatever> .

---

Einige Szenarien, die die Ergebnisse der verschiedenen Antworten veranschaulichen: http://jsfiddle.net/drzaus/UVjM4/

(Beachten Sie, dass die Verwendung von var para in Tests machen einen Unterschied, wenn sie in einem scoped wrapper durchgeführt werden)

Code als Referenz:

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

Und Ergebnisse:

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