Erkennen einer undefinierten Objekteigenschaft

https://stackoverflow.com/questions/27509

09-06-2019
|

Frage

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

Lösung

Verwenden:

if (typeof something === "undefined") {
    alert("something is undefined");
}

Wenn eine Objektvariable einige Eigenschaften hat, können Sie dasselbe wie folgt verwenden:

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}

Andere Tipps

Ich glaube, dass es zu diesem Thema eine Reihe falscher Antworten gibt.Entgegen der landläufigen Meinung ist „undefiniert“. nicht ein Schlüsselwort in JavaScript, dem tatsächlich ein Wert zugewiesen werden kann.

Richtiger Code

Die robusteste Methode zur Durchführung dieses Tests ist:

if (typeof myVar === "undefined")

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

Entarteter Code.VERWENDE NICHT.

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

Zusätzlich, myVar === undefined löst einen Fehler aus, wenn myVar nicht deklariert ist.

Obwohl es von vielen anderen Antworten hier vehement empfohlen wird, typeof ist eine schlechte Wahl.Es sollte niemals zur Überprüfung verwendet werden, ob Variablen den Wert haben undefined, da es sich um eine kombinierte Prüfung des Werts handelt undefined und ob eine Variable existiert.In den allermeisten Fällen wissen Sie, wann eine Variable existiert und typeof führt lediglich zu einem potenziellen stillen Fehler, wenn Sie einen Tippfehler im Variablennamen oder im String-Literal 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!
}

Es sei denn, Sie führen eine Feature-Erkennung² durch, bei der Unsicherheit besteht, ob ein bestimmter Name im Gültigkeitsbereich liegt (z. B. bei der Überprüfung). typeof module !== 'undefined' als Schritt im Code, der für eine CommonJS-Umgebung spezifisch ist), typeof ist eine schädliche Wahl, wenn sie auf eine Variable angewendet wird, und die richtige Option besteht darin, den Wert direkt zu vergleichen:

var foo = …;

if (foo === undefined) {
    ⋮
}

Einige häufige Missverständnisse hierzu sind:

dass das Lesen einer „nicht initialisierten“ Variablen (var foo) oder Parameter (function bar(foo) { … }, genannt als bar()) wird versagen.Das ist einfach nicht wahr – Variablen ohne explizite Initialisierung und Parameter, denen keine Werte zugewiesen wurden, werden immer initialisiert undefined, und sind immer im Geltungsbereich.
Das undefined kann überschrieben werden.Da steckt noch viel mehr dahinter. undefined ist kein Schlüsselwort in JavaScript.Stattdessen handelt es sich um eine Eigenschaft des globalen Objekts mit dem Wert „Undefiniert“.Seit ES5 gibt es diese Eigenschaft jedoch schreibgeschützt Und nicht konfigurierbar.Kein moderner Browser erlaubt das undefined Eigentum geändert werden, und seit 2017 ist dies schon seit langem der Fall.Das Fehlen eines strikten Modus hat keine Auswirkungen undefineds Verhalten auch – es macht nur Aussagen wie undefined = 5 nichts tun, statt zu werfen.Da es sich jedoch nicht um ein Schlüsselwort handelt, können Sie dies tun erklären Variablen mit dem Namen undefined, und diese Variablen könnten geändert werden, wodurch dieses früher übliche Muster entsteht:
```
(function (undefined) {
    // …
})()
```
mehr gefährlicher als die Verwendung des Global undefined.Wenn Sie ES3-kompatibel sein müssen, ersetzen Sie es undefined mit void 0 – nicht darauf zurückgreifen typeof. (void war schon immer ein unärer Operator, der für jeden Operanden den undefinierten Wert ergibt.)

Nachdem wir die Funktionsweise von Variablen geklärt haben, ist es an der Zeit, sich mit der eigentlichen Frage zu befassen:Objekteigenschaften.Es gibt keinen Grund, es jemals zu verwenden typeof für Objekteigenschaften.Die frühere Ausnahme bezüglich der Merkmalserkennung gilt hier nicht – typeof hat nur ein besonderes Verhalten bei Variablen und Ausdrücke, die auf Objekteigenschaften verweisen, sind keine Variablen.

Das:

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

Ist immer genau gleichwertig dazu³:

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

und unter Berücksichtigung der oben genannten Ratschläge, um die Leser nicht darüber zu verwirren, warum Sie es verwenden typeof, weil die Verwendung am sinnvollsten ist === um auf Gleichheit zu prüfen, weil es so umgestaltet werden könnte, dass es später den Wert einer Variablen überprüft, und weil es einfach besser aussieht, sollten Sie immer verwenden === undefined³ auch hier.

Wenn es um Objekteigenschaften geht, sollten Sie außerdem berücksichtigen, ob Sie wirklich nachsehen möchten undefined überhaupt.Ein bestimmter Eigenschaftsname kann bei einem Objekt fehlen (was den Wert erzeugt). undefined beim Lesen), auf dem Objekt selbst mit dem Wert vorhanden undefined, vorhanden auf dem Prototyp des Objekts mit dem Wert undefined, oder auf einem von denen mit einem nicht anwesendenundefined Wert. 'key' in obj wird Ihnen sagen, ob sich ein Schlüssel irgendwo in der Prototypenkette eines Objekts befindet, und Object.prototype.hasOwnProperty.call(obj, 'key') wird Ihnen sagen, ob es sich direkt auf dem Objekt befindet.Ich werde in dieser Antwort jedoch nicht näher auf Prototypen und die Verwendung von Objekten als Karten mit Zeichenfolgen eingehen, da sie hauptsächlich dazu gedacht ist, allen schlechten Ratschlägen in anderen Antworten entgegenzuwirken, unabhängig von den möglichen Interpretationen der ursprünglichen Frage.Lesen Sie weiter Objektprototypen auf MDN für mehr!

_{¹ ungewöhnliche Wahl des Beispielvariablennamens?Das ist echter toter Code aus der NoScript-Erweiterung für Firefox.}
_{² Gehen Sie jedoch nicht davon aus, dass es im Allgemeinen in Ordnung ist, den Umfang nicht zu kennen.Bonus-Schwachstelle durch Missbrauch des dynamischen Bereichs: Projekt Null 1225}
_{³ Wieder einmal unter der Annahme einer ES5+-Umgebung und so weiter undefined bezieht sich auf undefined Eigenschaft des globalen Objekts.Ersatz void 0 ansonsten.}

In JavaScript gibt es Null und da ist nicht definiert.Sie haben unterschiedliche Bedeutungen.

nicht definiert bedeutet, dass der Variablenwert nicht definiert wurde;Es ist nicht bekannt, wie hoch der Wert ist.
Null bedeutet, dass der Variablenwert definiert und auf null gesetzt ist (keinen Wert hat).

Marijn Haverbeke erklärt in seinem kostenlosen Online-Buch: „Eloquentes JavaScript" (Hervorhebung von mir):

Es gibt auch einen ähnlichen Wert, null, dessen Bedeutung ist: „Dieser Wert ist definiert, hat aber keinen Wert.“Der Bedeutungsunterschied zwischen undefiniert und null ist größtenteils akademischer Natur und normalerweise nicht sehr interessant. In praktischen Programmen muss oft überprüft werden, ob etwas „einen Wert hat“.In diesen Fällen kann der Ausdruck „etwas == undefiniert“ verwendet werden, da null == undefiniert „true“ ergibt, auch wenn sie nicht genau den gleichen Wert haben.

Ich denke, der beste Weg, um zu überprüfen, ob etwas undefiniert ist, 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 unterschiedliche Dinge bedeuten!Erstens kann es bedeuten die Eigenschaft, die nie definiert wurde im Objekt und zweitens kann es das bedeuten Eigenschaft, die einen undefinierten Wert hat.Schauen wir uns diesen Code an:

var o = { a: undefined }

Ist o.a nicht definiert?Ja!Sein Wert ist undefiniert.Ist o.b nicht definiert?Sicher!Es gibt überhaupt keine Eigenschaft „b“!OK, sehen Sie sich jetzt an, 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

Das können wir deutlich erkennen typeof obj.prop == 'undefined' Und obj.prop === undefined sind gleichwertig und unterscheiden diese unterschiedlichen Situationen nicht.Und 'prop' in obj kann die Situation erkennen, in der eine Eigenschaft überhaupt nicht definiert wurde, und achtet nicht auf den Eigenschaftswert, der möglicherweise undefiniert ist.

Was also tun?

1) Sie möchten wissen, ob eine Eigenschaft weder durch die erste noch durch die 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 sein Wert ist Ihnen egal.

'prop' in obj

Anmerkungen:

Sie können ein Objekt und seine Eigenschaft nicht gleichzeitig überprüfen.Zum Beispiel dieses x.a === undefined oder dieses typeof x.a == 'undefined' erhöht ReferenceError: x is not defined wenn x nicht definiert ist.
Variable undefined ist eine globale Variable (also tatsächlich). window.undefined in Browsern).Es wird seit ECMAScript 1. Edition und seit ECMAScript 5 unterstützt schreibgeschützt.In modernen Browsern kann dies also nicht der Fall sein auf true umdefiniert mit dem uns viele Autoren gerne Angst machen, aber das gilt immer noch für ältere Browser.

Endkampf: `obj.prop === undefined` vs `typeof obj.prop == 'undefined'`

Pluspunkte von obj.prop === undefined:

Es ist etwas kürzer und sieht etwas hübscher aus
Die JavaScript-Engine gibt Ihnen eine Fehlermeldung aus, wenn Sie sich falsch geschrieben haben undefined

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

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

'undefned' (falsch geschrieben) ist hier nur eine String-Konstante, daher kann Ihnen die JavaScript-Engine nicht helfen, wenn Sie sie falsch geschrieben haben, wie ich es gerade getan habe.

Update (für serverseitiges JavaScript):

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

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

Das Objekt hat die Eigenschaft, sein Wert jedoch nicht undefined.
Das Objekt hat die Eigenschaft und sein Wert ist undefined.
Das Objekt verfügt nicht über die Eigenschaft.

Das 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 leider typeof obj.foo sagt uns nicht, welchen der drei Fälle wir haben.Wir können dies jedoch mit 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 für gleich sind null Einträge auch

                               |  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 von ein tatsächlicher Eintrag im Objekt mit einem undefinierten Wert.

Zum Beispiel:Ich habe gerade eine Menge Code umgestaltet, der eine Reihe von Überprüfungen enthielt, ob ein Objekt eine bestimmte Eigenschaft hatte.

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

Was klarer war, wenn 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 gleich (aber für meine Bedürfnisse mehr als gut genug).

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

Das hat bei mir funktioniert, bei den anderen nicht.

Ich bin mir nicht sicher, wo der Ursprung der Verwendung liegt === mit typeof stammt, und als Konvention sehe ich, dass es in vielen Bibliotheken verwendet wird, aber der Operator „typeof“ gibt ein String-Literal zurück, und das wissen wir im Voraus. Warum sollten Sie es also auch einer Typprüfung unterziehen?

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 meine Antwort aus verwandter Frage Wie kann ich in JavaScript nach „undefiniert“ suchen?

Spezifisch 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 für in Tests machen einen Unterschied, wenn sie sich in einem bereichsbezogenen Wrapper befinden)

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 wird fehlschlagen, wenn die Variable myvar existiert nicht, da myvar nicht definiert ist, sodass das Skript fehlerhaft ist und der Test keine Auswirkung hat.

Da das Fensterobjekt einen globalen Gültigkeitsbereich (Standardobjekt) außerhalb einer Funktion hat, wird eine Deklaration an das Fensterobjekt „angehängt“.

Zum Beispiel:

var myvar = 'test';

Die globale Variable myvar ist das gleiche wie window.myvar oder Fenster['myvar']

Um Fehler beim Testen der Existenz einer globalen Variablen zu vermeiden, verwenden Sie besser Folgendes:

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 albern, Variablen mit undefiniert zu initialisieren, und es ist besser, zum Initialisieren den Wert false 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 um zu überprüfen, ob es einen richtigen/gültigen Wert hat.Also auch dann, wenn die Variable nicht definiert ist !window.myvar ist das gleiche für myvar = undefined oder myvar = false oder myvar = 0.

Wenn Sie einen bestimmten Typ erwarten, testen Sie den Typ der Variablen.Um das Testen einer Bedingung zu beschleunigen, gehen Sie besser wie folgt vor:

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

Wenn die erste und einfache Bedingung wahr ist, überspringt der Interpreter 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 bietet eine bessere Programmiermethode.

(y)

Ich habe niemanden gesehen (ich hoffe, dass ich es nicht übersehen habe), 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.Das ist normalerweise das gewünschte Verhalten in den meisten Codeblockanweisungen (in JavaScript).

Im Artikel Erkundung der Abgründe von Null und Undefiniert in JavaScript Ich habe gelesen, dass Frameworks wie Underscore.js Benutze diese Funktion:

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

'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;) – Browser gibt keinen Fehler aus.

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

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

So funktioniert das:

Fenster ist ein Objekt, das alle globalen Variablen als seine Mitglieder enthält, und es ist zulässig, zu versuchen, auf ein nicht vorhandenes Mitglied zuzugreifen.Wenn X wurde nicht deklariert oder wurde dann nicht gesetzt window.x kehrt zurück nicht definiert. nicht definiert führt zu FALSCH Wann Wenn() wertet es aus.

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

Wenn ich das durchlese, wundere ich mich, 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, verhindert dies die Rückgabe true wenn es definiert ist als null oder undefined.Dies ist hilfreich, wenn Sie möchten, dass für Werte, die als festgelegt sind, „true“ zurückgegeben wird undefined

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

Definiert als undefiniert oder nie definiert

Wenn Sie möchten, dass das Ergebnis so ist true für Werte, die mit dem Wert von definiert sind undefined, oder nie definiert, 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.

Häufig wurde ich nach einem Algorithmus gefragt, um herauszufinden, ob ein Wert entweder falsch ist, undefined, oder null.Folgendes funktioniert.

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

Mit dem folgenden Code können Sie ein völlig undefiniertes Array mit Pfad erhalten.

 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 Verknüpfung

Es ist einfach alles, was in JavaScript nicht definiert ist nicht definiert, spielt keine Rolle, ob es sich um eine Eigenschaft innerhalb eines Objekts/Arrays oder nur um eine einfache Variable handelt ...

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

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

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

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

Wenn Sie also sehen, dass die Funktion einen Wert empfängt, wird dieser zurückgegeben, wenn dieser definiert ist false, andernfalls für undefinierte Werte Rückgabe 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. Die Ergebnisse können Sie als Kommentar davor 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 verwenden typeof in Ihrem Code, aber wenn Sie es immer wieder verwenden, erstellen Sie eine Funktion wie das Winkelbeispiel, das ich teile, und verwenden Sie es weiterhin als folgendes DRY-Codemuster.

Und noch etwas: Um die Eigenschaften eines Objekts in einer realen Anwendung zu überprüfen, bei der Sie nicht sicher sind, ob das Objekt überhaupt existiert oder nicht, prüfen Sie zunächst, ob das Objekt existiert.

Wenn Sie eine Eigenschaft eines Objekts überprüfen und das Objekt nicht existiert, 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, dass Sie eine if-Anweisung wie folgt einschließen können:

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 Underscore verfügen über eine ähnliche Definitionsprüfung, ich empfehle Ihnen jedoch, sie zu verwenden typeof wenn Sie bereits keine Frameworks verwenden.

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

Strikte Gleichheit und undefiniert
Sie können undefined und die strikten Gleichheits- und Ungleichheitsoperatoren verwenden, um zu bestimmen, ob eine Variable einen Wert.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
}

Notiz:Der strikte Gleichheitsoperator anstelle der Standardgleichheit muss hier verwendet werden, da x == undefined auch prüft, ob x ist null, während strikte Gleichheit nicht null ist.null ist nicht gleichbedeutend mit undefiniert.Einzelheiten finden Sie unter Vergleichsoperatoren.

Typ des Operators und undefiniert
Alternativ kann typeof verwendet werden:

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

Ein Grund für die Verwendung von typeof ist, dass es keinen Fehler auslöst, 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 der Technik sollte jedoch vermieden werden.JavaScript ist ein Sprache mit statischem Geltungsbereich, so dass das Wissen, ob eine Variable deklariert ist, gelesen werden, indem man sieht, ob es in einem einschließenden Kontext deklariert ist.Das Die einzige Ausnahme ist der globale Bereich, aber der globale Bereich ist an das globale Objekt, so dass das Vorhandensein einer Variablen in der globalen Kontext kann durch Überprüfen des Vorhandenseins einer Eigenschaft auf Das globale Objekt (z. B. mit dem in-Operator).

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

Vergleichen mit void 0, für 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“ werden und false sind.Der richtige Weg wäre zu überprüfen

if (something === undefined)

Welches ist der Identitätsoperator ...

Hier ist meine Situation:

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

Es gibt einen Fehler, den ich verteidigen muss.Wenn die Argumente für den Rest-Aufruf falsch waren, sofern der Benutzer die Argumente falsch angegeben hat, kommt der Rest-Aufruf im Wesentlichen leer zurück.

Während ich diesen Beitrag nutzte, um mich dagegen zu verteidigen, habe ich Folgendes versucht.

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

Wenn in meiner Situation restResult.data[0] === „object“ ist, kann ich sicher mit der Inspektion der restlichen Mitglieder beginnen.Wenn undefiniert, wird der Fehler wie oben ausgegeben.

Ich möchte damit sagen, dass in meiner Situation alle oben in diesem Beitrag aufgeführten Vorschläge nicht funktioniert haben.Ich sage nicht, dass ich Recht habe und alle Unrecht haben.Ich bin überhaupt kein JavaScript-Meister, aber hoffentlich hilft das jemandem.

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

var a = obj.prop || defaultValue;

Es eignet sich, 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);

}

Wird jetzt ausgeführt

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, die in falschen Antworten vergraben ist >_<

Also, für jeden, der vorbeikommt, gebe ich euch undefiniert kostenlos!!

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, können Sie für diejenigen, die beides überprüfen möchten, feststellen, ob es undefiniert ist oder ob sein Wert null ist:

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

Wenn Sie die jQuery-Bibliothek verwenden, dann jQuery.isEmptyObject() wird für beide Fälle ausreichen,

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 bei mir fehl.Es stellt sich heraus, dass es nur funktioniert, wenn die Variable ein Feld eines Objekts ist. obj.someField um zu überprüfen, ob es im Wörterbuch definiert ist.Aber wir können es gebrauchen this oder window als Wörterbuchobjekt, da jede Variable, soweit ich es verstehe, ein Feld im aktuellen Fenster ist.Deshalb hier ein Test

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

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

Zuerst wird diese Variable erkannt abc ist undefiniert und wird nach der Initialisierung definiert.

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

Gibt „false“ zurück, wenn die Variable gesetzt ist, und „true“, wenn sie undefiniert ist.

Dann benutze:

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

Die gleichen Dinge können auch kürzer geschrieben werden:

if (!variable){
    //do it if variable is Undefined
}

oder

if (variable){
    //do it if variable is Defined
}

Ich möchte Ihnen etwas zeigen, das ich verwende, um das zu schützen undefined Variable:

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

Dies verbietet es jedem, das zu ändern window.undefined Wert zerstört daher den Code, der auf dieser Variablen basiert.Bei Verwendung "use strict", wird jeder Versuch, seinen Wert zu ändern, mit einem Fehler enden, andernfalls würde er stillschweigend ignoriert werden.

Von lodash.js.

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

Es erstellt eine LOCAL-Variable mit dem Namen undefined die mit dem Standardwert initialisiert wird – dem Realwert undefined, dann vergleicht value mit der Variablen undefined.

Für diejenigen, die seltsame Antworten erwarten, stelle ich hier drei Möglichkeiten zur Verfügung:

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

isUndefiniert1:

Versuchen Sie, eine Eigenschaft des Eingabewerts abzurufen, und überprüfen Sie die Fehlermeldung, falls vorhanden.Wenn der Eingabewert undefiniert ist, würde die Fehlermeldung lauten Nicht erfasster TypeError:Eigenschaft 'b' von undefiniert kann nicht gelesen werden

isUndefiniert2:

Konvertieren Sie den Eingabewert zum Vergleich in eine Zeichenfolge "undefined" und stellen Sie sicher, dass es sich um einen negativen Wert handelt.

isUndefiniert3:

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

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow