Erkennen einer undefinierten Objekteigenschaft

2840

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

Matt Sheppard
quelle

Antworten:

2680

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`");
}
Ry-
quelle
9
Wenn etwas null ist, wird es definiert (als null), aber Sie können auch die Prüfungen konjugieren. Das ärgerliche Detail des obigen Codes ist, dass Sie keine Funktion definieren können, um sie zu überprüfen. Nun, Sie können die Funktion definieren ... aber versuchen Sie, sie zu verwenden.
Neu-Rah
5
@ neu-rah warum kannst du keine funktion schreiben? warum sollte so etwas nicht funktionieren? Es scheint für mich zu funktionieren. Gibt es einen Fall, den ich nicht in Betracht ziehe? jsfiddle.net/djH9N/6
Zack
7
@Zack Bei Ihren Tests für isNullorUndefined wurde der Fall nicht berücksichtigt, in dem Sie isNullOrUndefined (f) aufrufen und f nicht deklariert ist (dh wenn keine "var f" -Deklaration vorhanden ist).
pnkfelix
109
Blah, jetzt Tausende von Stimmen. Dies ist der schlechteste Weg, dies zu tun. Ich hoffe, Passanten sehen diesen Kommentar und beschließen,… ähm… andere Antworten zu überprüfen .
Ry-
17
Sie können nur obj !== undefinedjetzt verwenden. undefinedFrüher war es veränderlich, undefined = 1234was interessante Ergebnisse bringen würde. Nach Ecmascript 5 ist es jedoch nicht mehr beschreibbar, sodass wir die einfachere Version verwenden können. codereadability.com/how-to-check-for-undefined-in-javascript
Bruno Buccolo
899

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.

MarkPflug
quelle
133
+1 für die Feststellung, dass myVar === undefined einen Fehler auslöst, wenn myVar nicht deklariert wurde
Enrique
73
Ich finde hier die erste Rechtfertigung dafür, keine === undefinedVerwirrung zu stiften. Ja, Sie können zuweisen undefined, aber es gibt keinen legitimen Grund dafür, und es ist vorhersehbar, dass dies Ihren Code beschädigen kann. In C können Sie #define true false, und in Python können Sie zuweisen Trueund False, aber die Leute fühlen sich nicht die Notwendigkeit , ihren Code in diesen Sprachen so zu gestalten , wie zum Schutz gegen die Möglichkeit , mich bewusst ihre eigene Umgebung an anderer Stelle im Code zu sabotieren . Warum ist die Möglichkeit der Zuordnung hier undefinedüberhaupt erwägenswert?
Mark Amery
19
Zusätzlich zu Marks Kommentaren erhalte ich Folgendes nicht: "myVar === undefined löst einen Fehler in der Situation aus, in der myVar nicht deklariert ist." - Warum ist das so schlimm? Warum sollte ich keinen Fehler haben wollen, wenn ich auf nicht deklarierte Variablen verweise?
Eis
5
Denken Sie auch void 0daran, dass Sie immer tun können , um den Wert zu erhalten, undefinedauf den gezeigt wird. So können Sie tun if (myVar === void 0). Das 0ist nichts Besonderes, man kann dort buchstäblich jeden Ausdruck setzen.
Claudiu
28
In modernen Browsern (FF4 +, IE9 +, Chrome unbekannt) können Änderungen nicht mehr vorgenommen werden undefined. MDN: undefiniert
user247702
228

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 .

Ry-
quelle
@BenjaminGruenbaum Richtig, aber völlig irreführend. Jeder nicht standardmäßige Kontext kann seinen eigenen definieren undefinedund den Standardkontext ausblenden. Was für die meisten praktischen Zwecke den gleichen Effekt hat wie das Überschreiben.
Blgt
23
@blgt Das ist paranoid und irrelevant für alles Praktische. Jeder Kontext kann console.log überschreiben, Array-Prototypmethoden neu definieren und sogar Function.prototype.call`-Hooking überschreiben und jedes Mal ändern, wenn Sie eine Funktion in JavaScript aufrufen. Der Schutz davor ist sehr paranoid und ziemlich albern. Wie ich (und Minitech) gesagt haben, können Sie void 0mit undefinierten vergleichen, aber wieder - das ist albern und übertrieben.
Benjamin Gruenbaum
19
Ich wünschte, ich hätte mehr als eine Gegenstimme zu geben. Dies ist die richtigste Antwort. Ich möchte wirklich aufhören, typeof something === "undefined") im Code zu sehen.
Simon Baumgardt-Wellander
@BenjaminGruenbaum Für faule Programmierer void 0ist ( ausnahmsweise ) sowohl kürzer als auch sicherer! Das ist ein Gewinn in meinem Buch.
wizzwizz4
4
Dies sollte wirklich die akzeptierte Antwort sein. Es ist das gründlichste und aktuellste.
Patrick Michaelsen
161

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
Pandincus
quelle
42
if (etwas == undefiniert) ist besser geschrieben als wenn (etwas === undefiniert)
Sebastian Rittau
59
Es sollte darauf hingewiesen werden, dass dies nicht ganz sicher ist. undefinedist nur eine Variable, die vom Benutzer neu zugewiesen werden kann: Das Schreiben undefined = 'a';führt dazu, dass Ihr Code nicht mehr das tut, was Sie denken. Die Verwendung typeofist besser und funktioniert auch für Variablen (nicht nur Eigenschaften), die nicht deklariert wurden.
Gabe Moothart
7
Wenn etwas eine undefinierte globale Variable ist, wird (etwas == undefiniert) ein Javascript-Fehler angezeigt.
Morgan Cheng
8
Das Problem dabei ist, dass wenn var a = null ist, a == undefined als true ausgewertet wird, obwohl a mit Sicherheit definiert ist.
Andrew
6
Diese Interpretation des Kommentars "Eloquent Javascript" ist rückwärts . Wenn Sie wirklich nur nach undefiniert suchen möchten, funktioniert der vorgeschlagene Code nicht (er erkennt auch die definierte Bedingung, aber es wurde noch kein Wert zugewiesen [ienull]). Ein Nullwert. Der vorgeschlagene Code "if (etwas == undefiniert) ..." prüft sowohl auf undefiniert als auch auf null (kein Wert festgelegt), dh er wird interpretiert als "if ((etwas ist undefiniert) ODER (etwas ist null)) ..." Was der Autor sagt , ist , dass oft das, was Sie wirklich wollen , ist , zu überprüfen , sowohl undefined und null.
Chuck Kollars
125

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.

Konstantin Smolyanin
quelle
@Bergi danke für deinen Kommentar. Ich habe meine Antwort korrigiert. Zu meiner Verteidigung kann ich sagen, dass derzeit (ab Version 0.10.18) die offizielle Dokumentation von Node.js nichts darüber aussagt, undefinedals Mitglied von global. Weder auch console.log(global);noch for (var key in global) { ... }nicht zeigen nicht definiert als Mitglied des globalen . Aber teste gerne 'undefined' in globaldas Gegenteil.
Konstantin Smolyanin
4
Es brauchte keine zusätzliche Dokumentation, da es in der EcmaScript-Spezifikation ist , die auch sagt, dass [[Enumerable]]das falsch ist :-)
Bergi
5
In Bezug auf Minuses of typeof obj.prop == 'undefined', kann dies durch das Schreiben wie vermieden werden typeof obj.prop == typeof undefined. Dies ergibt auch eine sehr schöne Symmetrie.
Hlovdal
3
@hlovdal: Das ist völlig sinnlos , gegen obj.prop === undefined.
Ry-
1
Wenn wir der Überschrift Erkennen einer undefinierten Eigenschaft“ treu bleiben , nicht der (anderen und viel einfacheren) Frage im ersten Satz („Überprüfen Sie, ob undefiniert ...“), antworten Sie if ('foo' in o)… Ihre Antwort ist wirklich die erste richtige Antwort hier. So ziemlich alle anderen beantworten nur diesen Satz.
Frank Nocke
70

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

Michael Anderson
quelle
10
Hallo Michael. Toller Vorschlag, und ich denke, das macht die Dinge sauberer. Ein Problem, das ich jedoch gefunden habe, ist die Verwendung des! Operator mit "in". Man muss if (!("x" in blob)) {}mit Klammern um das In sagen , weil das! Der Operator hat Vorrang vor 'in'. Hoffe das hilft jemandem.
Simon East
Sorry Michael, aber das ist angesichts der ursprünglichen Frage falsch oder zumindest irreführend. 'in' ist keine ausreichende Methode, um zu testen, ob eine Objekteigenschaft den Typ undefined hat. Zum Beweis sehen Sie bitte diese Geige: jsfiddle.net/CsLKJ/4
tex
2
Diese beiden Codeteile machen etwas anderes! Betrachten und Objekt gegeben durch a = {b: undefined}; dann typeof a.b === typeof a.c === 'undefined'aber 'b' in aund !('c' in a).
mgol
3
+1. Das OP macht nicht klar, ob die Eigenschaft existiert und den Wert undefiniert hat oder ob die Eigenschaft selbst undefiniert ist (dh nicht existiert).
RobG
Ich würde vorschlagen, Punkt (2.) in Ihrer ersten Tabelle zu ändern { x : undefined }oder ihn zumindest als eine andere Alternative zu (2.) in der Tabelle hinzuzufügen - ich musste einen Moment nachdenken, um zu erkennen, dass Punkt (2.) undefined(obwohl ) bewertet wird Sie erwähnen das später).
Mucaho
46
if ( typeof( something ) == "undefined") 

Das hat bei mir funktioniert, die anderen nicht.

Kevin
quelle
47
parens sind unnötig, da typeof ein Operator ist
aehlke
12
Aber sie machen klarer, was überprüft wird. Andernfalls könnte es als gelesen werden typeof (something == "undefined").
Abhi Beckert
Wenn Sie die Klammern benötigen, sollten Sie die Priorität von Operatoren in JS lernen: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
Ian
11
Klammern sind gerade deshalb nützlich, weil Sie in JS weder die Priorität von Operatoren lernen noch spekulieren müssen, ob zukünftige Wartungsprogrammierer die Priorität von Operatoren in JS lernen müssen.
DaveWalley
27
Klammern sind nützlich, um Dinge zu klären. In diesem Fall sieht der Operator jedoch nur wie eine Funktion aus. Zweifellos verdeutlicht dies die Absicht des Programmierers. Wenn Sie sich jedoch nicht sicher sind, ob der Operator Vorrang hat, sollten Sie ihn lieber als schreiben (typeof something) === "undefined".
Robert
42

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
Eric
quelle
Großartiger Punkt, Eric. Gibt es auch einen Leistungseinbruch durch die Überprüfung des Typs?
Simon East
5
@ Simon: Ganz im Gegenteil - man könnte einen leichten Leistungseinbruch erwarten, wenn man im Fall '===' Zwang vermeidet. Schneller und schmutziger Test hat gezeigt, dass '===' 5% schneller ist als '==' unter FF5.0.1
Antony Hatchkins
5
Ein gründlicherer Test hat gezeigt, dass IE und Chrome unter FF '==' mehr oder weniger schneller sind als '===' (5-10%) und Opera überhaupt keinen Unterschied macht: jsperf.com/triple- gleich-gegen-zweimal-gleich / 6
Antony Hatchkins
3
Die Verwendung ==erfordert immer noch mindestens eine Typprüfung - der Interpreter kann die beiden Operanden nicht vergleichen, ohne vorher ihren Typ zu kennen.
Alnitak
7
==ist ein Zeichen weniger als ===:)
svidgen
25

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
drzaus
quelle
21

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)

Codebeat
quelle
19

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

Joe Johnson
quelle
2
Wenn Sie wissen wollen, warum dies funktioniert: Javascript: Logische Operatoren und truthy / falsy
MB21
Wenn Sie die Eigenschaft einer Variablen zuweisen möchten, wenn sie definiert ist, nicht null und nicht falsey, andernfalls einen Standardwert verwenden, können Sie Folgendes verwenden: var x = obj && obj.prop || 'default';
Stijn de Witt
Ich glaube, die Frage ist, explizit gegen undefiniert zu prüfen. Ihre Zustandsprüfung gegen alle falschen Werte von JS.
NikoKyriakid
15

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;
}
Marthijn
quelle
3
void 0ist nur eine kurze Schreibweise undefined(da dies die Leere ist, gefolgt von einem Ausdruck), werden 3 Zeichen gespeichert. Es könnte auch funktionieren var a; return obj === a;, aber das ist noch ein Charakter. :-)
RobG
2
voidist ein reserviertes Wort, während undefinednicht das heißt, während undefinedheißt auf gleich void 0standardmäßig Sie einen Wert zuweisen können undefinedzB undefined = 1234.
Brian M. Hunt
isUndefined(obj): 16 Zeichen. obj === void 0: 14 Zeichen. 'nough sagte.
Stijn de Witt
14

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

Alireza
quelle
13

' 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.

DenisS
quelle
Aber was ist, wenn Sie in Node laufen? typeof history != 'undefined'funktioniert tatsächlich in beiden Systemen.
Stijn de Witt
13

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");
}
Travis
quelle
4
Ich denke, Sie können das letzte Beispiel durchif (!obj.prop)
Stijn de Witt
@StijndeWitt, Sie können, ich war ziemlich unerfahren, als ich dies schrieb, und mein Englisch scheint ebenso schlecht gewesen zu sein, dennoch ist nichts falsch in der Antwort
Travis
3
var obj = {foo: undefined}; obj.foo === void 0-> true. Wie ist das "nie definiert als undefined"? Das ist falsch.
Patrick Roberts
@PatrickRoberts Du hast recht. Als ich diese Antwort im Februar 2015 (vor ES6) schrieb, funktionierte die erste von mir skizzierte Option zwar, ist aber jetzt veraltet.
Travis
12
"propertyName" in obj //-> true | false
Sam
quelle
10

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

if (foo !== void 0)

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

bevacqua
quelle
3
Es wird jedoch ein ReferenceError ausgelöst, wenn fooes nicht deklariert ist.
Daniel1426
1
@ daniel1426: Wenn also ein Fehler in Ihrem Code vorliegt, möchten Sie ihn ausblenden, anstatt ihn zu beheben? Kein guter Ansatz, IMO.
Dies wird nicht verwendet, um Fehler auszublenden. Dies ist die übliche Methode, um die Eigenschaften der Umgebung zu erkennen und Polyfills zu definieren. Zum Beispiel: if (Typ des Versprechens === 'undefiniert') {/ * Versprechen definieren * /}
Gaperton
10

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 ...

Ricky
quelle
3
Um klar zu sein, ===ist Typ Gleichheit + (primitive Gleichheit | Objektidentität), wobei Primitive Zeichenfolgen enthalten. Ich denke, die meisten Leute halten es für nicht 'abab'.slice(0,2) === 'abab'.slice(2)intuitiv, wenn man es ===als Identitätsoperator betrachtet.
Clacke
1
Falsch. Dies löst einen Fehler aus, wenn die Variable nicht erstellt wurde. Sollte nicht gewählt werden. Verwenden Sie stattdessen typeof.
Simon East
10

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

Anoop
quelle
Obwohl dies die Gültigkeit Ihres Codes nicht beeinträchtigt, haben Sie einen Tippfehler: getUndefiendsollte sein getUndefined.
icktoofay
8

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.

Wayneseymour
quelle
Ihre typeofWache schützt sich eigentlich nicht vor etwas, mit dem ein direkter Vergleich nicht umgehen kann. Wenn restResultes nicht definiert oder nicht deklariert ist, wird es trotzdem werfen.
In Ihrem Fall könnten Sie einfacher überprüfen, ob das Array leer ist:if(!restResult.data.length) { throw "Some error"; }
Headbank
8

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
Marian Klühspies
quelle
7

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
Juan Garcia
quelle
7

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;
Angelin Nadar
quelle
jQuery kümmert sich auch um alle browserübergreifenden Kompatibilitätsprobleme mit den verschiedenen JavaScript-APIs.
Henry Heleine
7

Wenn Sie Angular verwenden:

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

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 
Vitalii Fedorenko
quelle
2
Wie füge ich eine 1Variable hinzu x? Benötige ich Unterstrich oder jQuery? (Erstaunlich, dass die Leute Bibliotheken selbst für die elementarsten Operationen wie einen typeofScheck benutzen )
Stijn de Witt
6

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.

Val
quelle
5

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.

blackmiaool
quelle
4
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
}
Rixius
quelle
5
Tu das nicht. Es ist nur ein sehr einfacher Test erforderlich, um zu beweisen, dass Sie einen typeofTest nicht sinnvoll in eine Funktion einschließen können. Erstaunlich, dass 4 Leute dies positiv bewertet haben. -1.
Stijn de Witt
4

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.

Seti
quelle
4

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
}
Sarkis Arutiunian
quelle
4

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;
}
lzl124631x
quelle