Wie kann am besten überprüft werden, ob eine Objekteigenschaft in JavaScript vorhanden ist undefined?

Die übliche Methode, um zu überprüfen, ob der Wert einer Eigenschaft der Sonderwert ist undefined, ist:

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

So überprüfen Sie, ob ein Objekt tatsächlich nicht über eine solche Eigenschaft verfügt und daher undefinedstandardmäßig zurückgegeben wird, wenn Sie versuchen, darauf zuzugreifen:

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

Überprüfen, ob der einem Bezeichner zugeordnete Wert der Sonderwert undefinedist oder ob dieser Bezeichner nicht deklariert wurde. Hinweis: Diese Methode ist die einzige Möglichkeit, ohne einen frühen Fehler auf einen nicht deklariertenundefined Bezeichner (Hinweis: anders als mit einem Wert von ) zu verweisen :

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

In JavaScript-Versionen vor ECMAScript 5 war die Eigenschaft "undefined" für das globale Objekt beschreibbar und daher eine einfache Überprüfung foo === undefined unerwartet verhalten, wenn sie versehentlich neu definiert wurde. In modernem JavaScript ist die Eigenschaft schreibgeschützt.

In modernem JavaScript ist "undefiniert" jedoch kein Schlüsselwort. Daher können Variablen in Funktionen als "undefiniert" bezeichnet werden und die globale Eigenschaft beschatten.

Wenn Sie sich über diesen (unwahrscheinlichen) Randfall Sorgen machen, können Sie den void-Operator verwenden , um den speziellen undefinedWert selbst zu erhalten:

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

Ich glaube, es gibt eine Reihe falscher Antworten auf dieses Thema. Entgegen der allgemeinen Meinung ist "undefiniert" kein Schlüsselwort in JavaScript und kann tatsächlich einem Wert zugewiesen werden.

Richtiger Code

Der robusteste Weg, um diesen Test durchzuführen, ist:

if (typeof myVar === "undefined")

Dies gibt immer das richtige Ergebnis zurück und behandelt sogar die Situation, in der myVar nicht deklariert ist.

Code entartet. VERWENDE NICHT.

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

Darüber hinaus myVar === undefinedwird ein Fehler in der Situation ausgelöst, in der myVar nicht deklariert ist.

Obwohl dies von vielen anderen Antworten vehement empfohlen wird, typeof ist es eine schlechte Wahl . Es sollte niemals zur Überprüfung verwendet werden, ob Variablen den Wert haben undefined, da es als kombinierte Überprüfung für den Wert undefinedund für die Existenz einer Variablen dient. In den allermeisten Fällen wissen Sie, wann eine Variable vorhanden ist, und typeofkönnen nur dann einen stillen Fehler verursachen, wenn Sie im Variablennamen oder im Zeichenfolgenliteral einen Tippfehler machen '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!
}

Wenn Sie also keine Feature-Erkennung² durchführen, bei der Ungewissheit besteht, ob ein bestimmter Name in den Geltungsbereich fällt (z. B. das Überprüfen typeof module !== 'undefined'als Schritt in Code, der für eine CommonJS-Umgebung spezifisch ist), typeofist dies eine schädliche Wahl, wenn es für eine Variable verwendet wird, und die richtige Option ist um den Wert direkt zu vergleichen:

var foo = …;

if (foo === undefined) {
    ⋮
}

Einige häufige Missverständnisse sind:

• Das Lesen einer nicht initialisierten Variablen ( var foo) oder eines Parameters ( function bar(foo) { … }als bezeichnet bar()) schlägt fehl. Dies ist einfach nicht wahr - Variablen ohne explizite Initialisierung und Parameter, denen keine Werte zugewiesen wurden undefined, werden immer und sind immer im Geltungsbereich.

• das undefinedkann überschrieben werden. Das ist noch viel mehr. undefinedist kein Schlüsselwort in JavaScript. Stattdessen ist es eine Eigenschaft für das globale Objekt mit dem Wert Undefined. Seit ES5 ist diese Eigenschaft jedoch schreibgeschützt und nicht konfigurierbar . Kein moderner Browser erlaubt es, die undefinedEigenschaft zu ändern, und seit 2017 ist dies schon lange der Fall. Das Fehlen eines strengen Modus wirkt sich auch nicht auf undefineddas Verhalten aus - es werden nur Aussagen gemacht, undefined = 5die nichts tun, anstatt zu werfen. Da es sich jedoch nicht um ein Schlüsselwort handelt, können Sie Variablen mit dem Namen deklarierenundefined , und diese Variablen können geändert werden, wodurch dieses einmal übliche Muster entsteht:

  (function (undefined) {
      // …
  })()

  mehr gefährlicher als die globale Verwendung undefined. Wenn Sie ES3-kompatibel sein müssen, ersetzen Sie undefineddurch void 0- greifen Sie nicht darauf zurück typeof. (war voidschon immer ein unärer Operator, der für jeden Operanden den undefinierten Wert ergibt.)

Mit der Funktionsweise von Variablen ist es an der Zeit, die eigentliche Frage zu beantworten: Objekteigenschaften. Es gibt keinen Grund, jemals typeofObjekteigenschaften zu verwenden. Die frühere Ausnahme zur Feature-Erkennung gilt hier nicht - sie hat typeofnur ein spezielles Verhalten für Variablen, und Ausdrücke, die auf Objekteigenschaften verweisen, sind keine Variablen.

Diese:

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

ist immer genau gleichbedeutend mit diesem³:

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

und unter Berücksichtigung der obigen Ratschläge, um zu vermeiden, dass die Leser verwirrt werden, warum Sie sie verwenden typeof, da es am sinnvollsten ist, die ===Gleichheit zu überprüfen, weil sie später überarbeitet werden könnte, um den Wert einer Variablen zu überprüfen, und weil dies einfach ist sieht besser aus, du solltest auch hier immer === undefined³ verwenden .

Wenn es um Objekteigenschaften geht, sollten Sie auch berücksichtigen, ob Sie wirklich nachsehen möchten undefined. Ein bestimmter Eigenschaftsname kann auf einem Objekt fehlen (den Wert undefinedbeim Lesen erzeugen ), auf dem Objekt selbst mit dem Wert undefinedvorhanden sein, auf dem Prototyp des Objekts mit dem Wert vorhanden sein oder auf einem der Objekte undefinedmit einem Nichtwert vorhanden undefinedsein. 'key' in objHier erfahren Sie, ob sich ein Schlüssel irgendwo in der Prototypenkette eines Objekts befindet, und Object.prototype.hasOwnProperty.call(obj, 'key')ob er sich direkt auf dem Objekt befindet. Ich werde in dieser Antwort auf Prototypen und die Verwendung von Objekten als Karten mit Zeichenfolgen nicht näher darauf eingehen, da sie hauptsächlich dazu gedacht sind, allen schlechten Ratschlägen in anderen Antworten entgegenzuwirken, unabhängig von den möglichen Interpretationen der ursprünglichen Frage. Lesen Sie weiterObjektprototypen auf MDN für mehr!

_{¹ ungewöhnliche Wahl des Beispielvariablennamens? Dies ist wirklich toter Code aus der NoScript-Erweiterung für Firefox.
² Gehen Sie jedoch nicht davon aus, dass es im Allgemeinen in Ordnung ist, nicht zu wissen, was in den Geltungsbereich fällt. Bonusanfälligkeit durch Missbrauch des dynamischen Bereichs: Project Zero 1225
³ setzt erneut eine ES5 + -Umgebung voraus und undefinedbezieht sich auf die undefinedEigenschaft des globalen Objekts. void 0sonst ersetzen .}

In JavaScript gibt es null und es ist undefiniert . Sie haben unterschiedliche Bedeutungen.

• undefiniert bedeutet, dass der Variablenwert nicht definiert wurde; Es ist nicht bekannt, was der Wert ist.
• null bedeutet, dass der Variablenwert definiert und auf null gesetzt wird (hat keinen Wert).

Marijn Haverbeke erklärt in seinem kostenlosen Online-Buch " Eloquent JavaScript " (Schwerpunkt Mine):

Es gibt auch einen ähnlichen Wert, null, dessen Bedeutung "dieser Wert ist definiert, aber er hat keinen Wert" lautet. Der Bedeutungsunterschied zwischen undefiniert und null ist meist akademisch und normalerweise nicht sehr interessant. In praktischen Programmen muss häufig geprüft werden, ob etwas „einen Wert hat“. In diesen Fällen kann der Ausdruck etwas == undefiniert verwendet werden, da null == undefiniert true erzeugt, obwohl sie nicht genau den gleichen Wert haben.

Ich denke, der beste Weg, um zu überprüfen, ob etwas undefiniert war, wäre:

if (something == undefined)

Hoffe das hilft!

Bearbeiten: Als Reaktion auf Ihre Bearbeitung sollten die Objekteigenschaften auf die gleiche Weise funktionieren.

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

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

Was bedeutet das: "undefinierte Objekteigenschaft" ?

Eigentlich kann es zwei ganz verschiedene Dinge bedeuten! Erstens kann es sich um die Eigenschaft handeln, die noch nie im Objekt definiert wurde, und zweitens um die Eigenschaft, die einen undefinierten Wert hat . Schauen wir uns diesen Code an:

var o = { a: undefined }

Ist o.aundefiniert? Ja! Sein Wert ist undefiniert. Ist o.bundefiniert? Sicher! Es gibt überhaupt keine Eigenschaft 'b'! OK, sehen Sie jetzt, wie sich unterschiedliche Ansätze in beiden Situationen verhalten:

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

Wir können das klar erkennen typeof obj.prop == 'undefined'und obj.prop === undefinedsind gleichwertig, und sie unterscheiden diese verschiedenen Situationen nicht. Und 'prop' in objkann die Situation erkennen, in der eine Eigenschaft überhaupt nicht definiert wurde und nicht auf den möglicherweise undefinierten Eigenschaftswert achtet.

Was tun?

1) Sie möchten wissen, ob eine Eigenschaft nicht durch die erste oder zweite Bedeutung definiert ist (die typischste Situation).

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

2) Sie möchten nur wissen, ob das Objekt eine Eigenschaft hat, und sich nicht um seinen Wert kümmern.

'prop' in obj

Anmerkungen:

• Sie können ein Objekt und seine Eigenschaft nicht gleichzeitig überprüfen. Dies x.a === undefinedoder dies wird beispielsweise typeof x.a == 'undefined'ausgelöst, ReferenceError: x is not definedwenn x nicht definiert ist.
• Variable undefinedist eine globale Variable (also tatsächlich window.undefinedin Browsern). Es wird seit ECMAScript 1st Edition unterstützt und ist seit ECMAScript 5 schreibgeschützt . In modernen Browsern kann es nicht neu definiert werden, da viele Autoren uns gerne erschrecken, aber dies gilt immer noch für ältere Browser.

Endkampf: obj.prop === undefinedvs.typeof obj.prop == 'undefined'

Pluspunkte von obj.prop === undefined:

• Es ist etwas kürzer und sieht etwas hübscher aus
• Die JavaScript-Engine gibt einen Fehler aus, wenn Sie falsch geschrieben haben undefined

Minuspunkte von obj.prop === undefined:

• undefined kann in alten Browsern überschrieben werden

Pluspunkte von typeof obj.prop == 'undefined':

• Es ist wirklich universell! Es funktioniert in neuen und alten Browsern.

Minuspunkte von typeof obj.prop == 'undefined':

• 'undefned'( falsch geschrieben ) Hier ist nur eine Zeichenfolgenkonstante, daher kann Ihnen die JavaScript-Engine nicht helfen, wenn Sie sie wie ich falsch geschrieben haben.

Update (für serverseitiges JavaScript):

Node.js unterstützt die globale Variable undefinedas global.undefined(sie kann auch ohne das Präfix 'global' verwendet werden). Ich kenne keine anderen Implementierungen von serverseitigem JavaScript.

Das Problem besteht aus drei Fällen:

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

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

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

Aber unglücklicherweise typeof obj.foosagt uns nicht, welchen der drei Fälle wir haben. Wir können dies jedoch kombinieren "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 ist erwähnenswert, dass diese Tests auch für nullEinträge gleich sind

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

Ich würde argumentieren, dass es in einigen Fällen sinnvoller (und klarer) ist, zu überprüfen, ob die Eigenschaft vorhanden ist, als zu überprüfen, ob sie undefiniert ist, und der einzige Fall, in dem diese Überprüfung anders sein wird, ist Fall 2, der seltene Fall von Ein tatsächlicher Eintrag im Objekt mit einem undefinierten Wert.

Beispiel: Ich habe gerade eine Reihe von Codes überarbeitet, bei denen überprüft wurde, ob ein Objekt eine bestimmte Eigenschaft hat.

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

Was klarer war, wenn ohne Prüfung auf undefiniert geschrieben wurde.

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

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

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

Das hat bei mir funktioniert, die anderen nicht.

Ich bin mir nicht sicher, woher der Ursprung der Verwendung ===mit typeofstammt, und als Konvention sehe ich, dass er in vielen Bibliotheken verwendet wird, aber der Operator typeof gibt ein Zeichenfolgenliteral zurück, und wir wissen das im Voraus. Warum sollten Sie also auch tippen? Überprüfen Sie es auch?

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 meiner Antwort von einer verwandten Frage Wie kann ich in JavaScript nach "undefiniert" suchen?

Speziell für diese 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 varfür inTests in einem Wrapper mit Gültigkeitsbereich einen Unterschied macht.)

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

Wenn Sie tun

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

Es myvarschlägt fehl, wenn die Variable nicht vorhanden ist, da myvar nicht definiert ist. Daher ist das Skript fehlerhaft und der Test hat keine Auswirkung.

Da das Fensterobjekt einen globalen Bereich (Standardobjekt) außerhalb einer Funktion hat, wird eine Deklaration an das Fensterobjekt angehängt.

Zum Beispiel:

var myvar = 'test';

Die globale Variable myvar ist dieselbe wie window.myvar oder window ['myvar']

Um Fehler beim Testen zu vermeiden, wenn eine globale Variable vorhanden ist, verwenden Sie besser:

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

Die Frage, ob eine Variable wirklich existiert, spielt keine Rolle, ihr Wert ist falsch. Andernfalls ist es dumm, Variablen mit undefined zu initialisieren, und es ist besser, den Wert false zum Initialisieren zu verwenden. Wenn Sie wissen, dass alle von Ihnen deklarierten Variablen mit false initialisiert sind, können Sie einfach ihren Typ überprüfen oder sich darauf verlassen !window.myvar, ob sie einen richtigen / gültigen Wert haben. Selbst wenn die Variable nicht definiert ist, !window.myvarist sie für myvar = undefinedoder myvar = falseoder gleich myvar = 0.

Wenn Sie einen bestimmten Typ erwarten, testen Sie den Typ der Variablen. Um das Testen einer Bedingung zu beschleunigen, sollten Sie Folgendes tun:

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

Wenn die erste und einfache Bedingung erfüllt ist, überspringt der Dolmetscher die nächsten Tests.

Es ist immer besser, die Instanz / das Objekt der Variablen zu verwenden, um zu überprüfen, ob sie einen gültigen Wert hat. Es ist stabiler und eine bessere Art der Programmierung.

(y)

Ich habe niemanden gesehen (ich hoffe, ich habe ihn nicht verpasst), der das Objekt vor dem Grundstück überprüft hat. Dies ist also die kürzeste und effektivste (wenn auch nicht unbedingt die klarste):

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

Wenn obj oder obj.prop undefiniert, null oder "falsch" ist, führt die if-Anweisung den Codeblock nicht aus. Dies ist normalerweise das gewünschte Verhalten in den meisten Codeblockanweisungen (in JavaScript).

In dem Artikel Exploring the Abyss of Null und Undefined in JavaScript habe ich gelesen, dass Frameworks wie Underscore.js diese Funktion verwenden:

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

Einfach ist nichts in JavaScript definiert, undefiniert , egal ob es sich um eine Eigenschaft innerhalb eines Objekts / Arrays handelt oder nur um eine einfache Variable ...

JavaScript hat typeof es sehr einfach, eine undefinierte Variable zu erkennen.

Überprüfen Sie einfach, ob typeof whatever === 'undefined' Sie und es wird ein Boolescher Wert zurückgegeben.

So wird die berühmte Funktion isUndefined()in AngularJs v.1x geschrieben:

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

Wenn Sie also sehen, dass die Funktion einen Wert erhält, wird dieser Wert zurückgegeben, wenn er definiert ist false. Andernfalls wird für undefinierte Werte zurückgegeben true.

Schauen wir uns also an, was die Ergebnisse sein werden, wenn wir Werte übergeben, einschließlich Objekteigenschaften wie unten. Dies ist die Liste der Variablen, die wir haben:

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

und wir überprüfen sie wie folgt, Sie können die Ergebnisse vor ihnen als Kommentar sehen:

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

Wie Sie sehen, können wir alles überprüfen, indem wir so etwas in unserem Code verwenden. Wie bereits erwähnt, können Sie es einfach typeofin Ihrem Code verwenden. Wenn Sie es jedoch immer wieder verwenden, erstellen Sie eine Funktion wie das eckige Beispiel, das ich teile, und verwenden Sie es weiterhin als folgendes DRY-Code-Muster.

Wenn Sie die Eigenschaft eines Objekts in einer realen Anwendung überprüfen möchten, bei der Sie nicht sicher sind, ob das Objekt vorhanden ist oder nicht, überprüfen Sie zunächst, ob das Objekt zuerst vorhanden ist.

Wenn Sie eine Eigenschaft für ein Objekt überprüfen und das Objekt nicht vorhanden ist, wird ein Fehler ausgegeben und die Ausführung der gesamten Anwendung gestoppt.

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

So einfach können Sie eine if-Anweisung wie folgt einschließen:

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

Was auch gleich isDefined in Angular 1.x ist ...

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

Auch andere Javascript-Frameworks wie der Unterstrich haben eine ähnliche Definitionsprüfung. Ich empfehle jedoch die Verwendung, typeofwenn Sie bereits keine Frameworks verwenden.

Ich füge auch diesen Abschnitt von MDN hinzu, der nützliche Informationen über typeof, undefined und void (0) enthält.

Strikte Gleichheit und undefiniert Mit
den Operatoren undefiniert und strikt gleich und ungleich können Sie bestimmen, ob eine Variable einen Wert hat. Im folgenden Code ist die Variable x nicht definiert, und die if-Anweisung wird als true ausgewertet.

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

Hinweis: Hier muss der Operator für strikte Gleichheit anstelle des Standardoperators für Gleichheit verwendet werden, da x == undefined auch prüft, ob x null ist, während strikte Gleichheit dies nicht tut. null ist nicht gleichbedeutend mit undefiniert. Einzelheiten finden Sie unter Vergleichsoperatoren.

Typ des Operators und undefiniert
Alternativ kann der Typ des verwendet werden:

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

Ein Grund für die Verwendung von typeof ist, dass kein Fehler ausgegeben wird, wenn die Variable nicht deklariert wurde.

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

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

}

Diese Art von Technik sollte jedoch vermieden werden. JavaScript ist eine Sprache mit statischem Gültigkeitsbereich. Wenn Sie also wissen, ob eine Variable deklariert ist, können Sie lesen, ob sie in einem umschließenden Kontext deklariert ist. Die einzige Ausnahme ist der globale Bereich, aber der globale Bereich ist an das globale Objekt gebunden. Daher kann die Überprüfung der Existenz einer Variablen im globalen Kontext durchgeführt werden, indem die Existenz einer Eigenschaft für das globale Objekt überprüft wird (mithilfe des Operators in, zum Beispiel).

Void Operator und undefiniert

Der Void-Operator ist eine dritte Alternative.

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

mehr> hier

' if (window.x) {} ' ist fehlersicher

Höchstwahrscheinlich möchten Sie if (window.x). Diese Prüfung ist auch dann sicher, wenn x nicht deklariert wurde ( var x;) - der Browser gibt keinen Fehler aus.

Beispiel: Ich möchte wissen, ob mein Browser die Verlaufs-API unterstützt

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

So funktioniert das:

window ist ein Objekt, das alle globalen Variablen als Mitglieder enthält, und es ist zulässig, auf ein nicht vorhandenes Mitglied zuzugreifen. Wenn x nicht deklariert wurde , ist oder nicht gesetzt wurde dann window.xzurückgibt undefiniert . undefined führt zu false, wenn if () es auswertet.

Ich bin erstaunt, dass ich das nicht gesehen habe. Ich habe mehrere Algorithmen gefunden, die dafür funktionieren würden.

Nie definiert

Wenn der Wert eines Objekts nie definiert wurde, wird die Rückgabe verhindert, truewenn es als nulloder definiert ist undefined. Dies ist hilfreich, wenn für Werte, die als festgelegt sind, true zurückgegeben werden sollundefined

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

Definiert als undefiniert oder nie definiert

Wenn Sie möchten, dass es sich trueum Werte handelt, die mit dem Wert von undefineddefiniert oder nie definiert wurden, können Sie einfach verwenden=== undefined

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

Definiert als falscher Wert, undefiniert, null oder nie definiert.

Im Allgemeinen haben mich Leute nach einem Algorithmus gefragt, um herauszufinden, ob ein Wert entweder falsch undefinedist oder null. Folgendes funktioniert.

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

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

Vergleichen Sie mit void 0, für die Knappheit.

if (foo !== void 0)

Es ist nicht so ausführlich wie if (typeof foo !== 'undefined')

Die Lösung ist falsch. In JavaScript

null == undefined

wird true zurückgeben, da beide in einen Booleschen Wert "umgewandelt" und false sind. Der richtige Weg wäre zu überprüfen

if (something === undefined)

Welches ist der Identitätsoperator ...

Mit dem folgenden Code können Sie ein Array erhalten, das alle undefiniert mit Pfad ist.

 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

Hier ist meine Situation:

Ich verwende das Ergebnis eines REST-Aufrufs. Das Ergebnis sollte von JSON in ein JavaScript-Objekt analysiert werden.

Es gibt einen Fehler, den ich verteidigen muss. Wenn die Argumente für den Restaufruf falsch waren, sofern der Benutzer die Argumente falsch angegeben hat, wird der Restaufruf im Grunde genommen leer zurückgegeben.

Während ich diesen Beitrag benutzte, um mich dagegen zu verteidigen, habe ich es versucht.

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

In meiner Situation kann ich, wenn restResult.data [0] === "object" ist, sicher damit beginnen, den Rest der Mitglieder zu inspizieren. Wenn undefiniert, werfen Sie den Fehler wie oben.

Was ich damit sagen will ist, dass für meine Situation alle oben genannten Vorschläge in diesem Beitrag nicht funktioniert haben. Ich sage nicht, dass ich Recht habe und jeder Unrecht hat. Ich bin überhaupt kein JavaScript-Meister, aber hoffentlich hilft dies jemandem.

Es gibt eine schöne und elegante Möglichkeit, einer neuen Variablen eine definierte Eigenschaft zuzuweisen, wenn sie definiert ist, oder ihr einen Standardwert als Fallback zuzuweisen, wenn sie nicht definiert ist.

var a = obj.prop || defaultValue;

Es ist geeignet, wenn Sie eine Funktion haben, die eine zusätzliche Konfigurationseigenschaft erhält:

var yourFunction = function(config){

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

}

Jetzt ausführen

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

yourFunction();
//=> 1

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

Alle Antworten sind unvollständig. Dies ist der richtige Weg, um zu wissen, dass es eine Eigenschaft gibt, die als undefiniert definiert ist:

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

Beispiel:

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

Schade, dass dies die richtige Antwort war, ist in falschen Antworten> _ <begraben

Also, für jeden, der vorbeikommt, werde ich Ihnen undefinierte kostenlos geben !!

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

Wenn Sie die Kommentare durchgehen, ist es für diejenigen, die beide überprüfen möchten, undefiniert oder der Wert ist null:

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

Wenn Sie jQuery Library verwenden jQuery.isEmptyObject(), reicht dies für beide Fälle aus:

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;

Wenn Sie Angular verwenden:

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

Underscore.js:

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

Ich benutze if (this.variable), um zu testen, ob es definiert ist. Einfach if (variable), oben empfohlen , schlägt für mich fehl. Es stellt sich heraus, dass es nur funktioniert, wenn Variable ein Feld eines Objekts ist, um obj.someFieldzu überprüfen, ob es im Wörterbuch definiert ist. Aber wir können thisoder windowals Wörterbuchobjekt verwenden, da jede Variable ein Feld im aktuellen Fenster ist, so wie ich es verstehe. Deshalb hier ein Test

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

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

Es erkennt zuerst, dass die Variable abcundefiniert ist und wird nach der Initialisierung definiert.

Ich biete hier drei Möglichkeiten für diejenigen, die seltsame Antworten erwarten:

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:

Versuchen Sie, eine Eigenschaft des Eingabewerts abzurufen, und überprüfen Sie die Fehlermeldung, falls vorhanden. Wenn der Eingabewert undefiniert ist, lautet die Fehlermeldung Uncaught TypeError: Die Eigenschaft 'b' von undefined kann nicht gelesen werden

isUndefined2:

Konvertieren Sie den Eingabewert in einen String, mit dem Sie vergleichen möchten "undefined" und stellen Sie sicher, dass er negativ ist.

isUndefined3:

In js funktioniert der optionale Parameter, wenn der Eingabewert genau ist undefined.

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

Gibt false zurück, wenn die Variable festgelegt ist, und true, wenn sie nicht definiert ist.

Dann benutze:

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

Ich möchte Ihnen etwas zeigen, das ich zum Schutz der undefinedVariablen verwende:

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

Dies verbietet jedem, den window.undefinedWert zu ändern, wodurch der auf dieser Variablen basierende Code zerstört wird. Bei Verwendung "use strict"endet alles, was versucht, seinen Wert zu ändern, mit einem Fehler, andernfalls wird es stillschweigend ignoriert.

Sie können auch Proxy verwenden. Es funktioniert mit verschachtelten Aufrufen, erfordert jedoch eine zusätzliche Überprüfung:

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

Sie werden es also wie folgt verwenden:

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // do someting
}

Von lodash.js.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

Es wird eine LOCAL-Variable mit dem Namen erstellt, undefineddie mit dem Standardwert initialisiert wird - dem Realwert - undefinedund dann valuemit der Variablen verglichen wird undefined.

Update 09.09.2019

Ich fand lodash aktualisiert seine Implementierung. Siehe mein Problem und den Code .

Um kugelsicher zu sein, verwenden Sie einfach:

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