Wie überprüfe ich, ob ein Objekt eine bestimmte Eigenschaft in JavaScript hat?

Wie überprüfe ich, ob ein Objekt eine bestimmte Eigenschaft in JavaScript hat?

Erwägen:

x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this
}

Ist das der beste Weg, es zu tun?

Ich bin wirklich verwirrt von den Antworten, die gegeben wurden - die meisten von ihnen sind einfach völlig falsch. Natürlich können Sie Objekteigenschaften haben, die undefinierte, null oder falsche Werte haben. Wenn Sie also einfach die Immobilienprüfung auf typeof this[property]oder, noch schlimmer, reduzieren x.key, erhalten Sie völlig irreführende Ergebnisse.

Es kommt darauf an, wonach Sie suchen. Wenn Sie wissen möchten, ob ein Objekt physisch eine Eigenschaft enthält (und nicht von irgendwo oben in der Prototypenkette stammt), dannobject.hasOwnProperty ist dies der richtige Weg. Alle modernen Browser unterstützen dies. (Es fehlte in älteren Versionen von Safari - 2.0.1 und älter - aber diese Versionen des Browsers werden selten mehr verwendet.)

Wenn Sie suchen, ob ein Objekt eine Eigenschaft enthält, die iterierbar ist (wenn Sie über die Eigenschaften des Objekts iterieren, wird es angezeigt), gehen Sie wie folgt vor: prop in object Sie erhalten den gewünschten Effekt.

Da die Verwendung hasOwnPropertywahrscheinlich das ist, was Sie möchten, und wenn Sie bedenken, dass Sie möglicherweise eine Fallback-Methode wünschen, präsentiere ich Ihnen die folgende Lösung:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

Das Obige ist eine funktionierende, browserübergreifende Lösung für hasOwnPropertyeine Einschränkung: Es kann nicht zwischen Fällen unterschieden werden, in denen sich eine identische Eigenschaft im Prototyp und in der Instanz befindet - es wird lediglich davon ausgegangen, dass sie vom Prototyp stammt. Sie könnten es je nach Ihrer Situation milder oder strenger gestalten, aber zumindest sollte dies hilfreicher sein.

Mit Underscore.jsoder ( noch besser ) lodash:

_.has(x, 'key');

Welche Aufrufe Object.prototype.hasOwnProperty, aber (a) ist kürzer zu tippen, und (b) verwendet "einen sicheren Verweis auf hasOwnProperty" (dh es funktioniert auch wennhasOwnProperty überschrieben wird).

Insbesondere definiert lodash _.hasals:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

Wie wäre es mit?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}

Hinweis : Folgendes ist heutzutage dank des strengen Modus und weitgehend veraltet hasOwnProperty. Die richtige Lösung besteht darin, den strengen Modus zu verwenden und mithilfe von das Vorhandensein einer Eigenschaft zu überprüfen obj.hasOwnProperty. Diese Antwort ist älter als diese beiden Dinge, mindestens so weit verbreitet (ja, es ist so alt). Nehmen Sie das Folgende als historische Notiz.

Beachten Sie, dass dies undefined(leider) kein reserviertes Wort in JavaScript ist, wenn Sie nicht den strengen Modus verwenden. Daher könnte jemand (offensichtlich jemand anderes) die großartige Idee haben, es neu zu definieren und Ihren Code zu brechen.

Eine robustere Methode ist daher die folgende:

if (typeof(x.attribute) !== 'undefined')

Auf der anderen Seite ist diese Methode viel ausführlicher und auch langsamer. : - /

Eine gemeinsame Alternative ist , um sicherzustellen , dass undefinedist eigentlich nicht definiert, zB indem Sie den Code in eine Funktion setzen , die einen zusätzlichen Parameter akzeptiert, genannt undefined, die keinen Wert übergeben wird. Um sicherzustellen, dass kein Wert übergeben wird, können Sie ihn sofort selbst aufrufen, z.

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

if (x.key !== undefined)

Armin Ronacher scheint mich schon geschlagen zu haben , aber:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');
}

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');
}

Eine sicherere, aber langsamere Lösung, wie von Konrad Rudolph und Armin Ronacher hervorgehoben, wäre:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';
};

Mit dem inOperator können Sie überprüfen, ob die Eigenschaft für ein Objekt vorhanden ist:

x = {'key': 1};
alert("key" in x);

Sie können auch alle Eigenschaften des Objekts mithilfe einer Schleife durchlaufen for - inund dann nach der spezifischen Eigenschaft suchen:

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

Sie müssen berücksichtigen, ob diese Objekteigenschaft aufzählbar ist oder nicht, da nicht aufzählbare Eigenschaften nicht in einer for-inSchleife angezeigt werden. Wenn die Eigenschaft enumerable eine nicht aufzählbare Eigenschaft des Prototyps überschattet, wird sie in Internet Explorer 8 und früheren Versionen nicht angezeigt .

Wenn Sie eine Liste aller Instanzeigenschaften wünschen, ob aufzählbar oder nicht, können Sie verwenden

Object.getOwnPropertyNames(x);

Dies gibt ein Array von Namen aller Eigenschaften zurück, die für ein Objekt vorhanden sind.

Schließlich können Sie den Operator typeof verwenden, um den Datentyp der Objekteigenschaft direkt zu überprüfen:

if (typeof x.key == "undefined") {
    alert("undefined");
}

Wenn die Eigenschaft für das Objekt nicht vorhanden ist, wird die Zeichenfolge undefiniert zurückgegeben. Andernfalls wird der entsprechende Eigenschaftstyp zurückgegeben. Beachten Sie jedoch, dass dies nicht immer eine gültige Methode ist, um zu überprüfen, ob ein Objekt eine Eigenschaft hat oder nicht, da Sie möglicherweise eine Eigenschaft haben, die auf undefiniert gesetzt ist. In diesem Fall verwenden Sietypeof x.key würde immer noch true zurückgeben (obwohl der Schlüssel noch vorhanden ist im Objekt).

Update: Sie können überprüfen, ob eine Eigenschaft vorhanden ist, indem Sie sie mit der undefinierten Javascript-Eigenschaft vergleichen

if (x.key === undefined) {
    alert("undefined");
}

Dies sollte funktionieren, es sei denn, der Schlüssel wurde speziell für undefineddas x-Objekt festgelegt

Lassen Sie uns hier einige Verwirrung beseitigen. Lassen Sie uns zunächst vereinfachen, indem wir annehmenhasOwnProperty bereits existiert. Dies gilt für die überwiegende Mehrheit der derzeit verwendeten Browser.

hasOwnPropertyGibt true zurück, wenn der Attributname, der an das Objekt übergeben wird, dem Objekt hinzugefügt wurde. Es ist völlig unabhängig von dem ihm zugewiesenen tatsächlichen Wert, der genau sein kann undefined .

Daher:

var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true

Jedoch:

var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

Das Problem ist, was passiert, wenn ein Objekt in der Prototypenkette ein Attribut mit dem Wert undefined hat? hasOwnPropertywird dafür falsch sein, und so wird es auch sein !== undefined. Noch,for..in wird es noch in der Aufzählung Liste.

Unter dem Strich gibt es keine browserübergreifende Möglichkeit (da Internet Explorer dies nicht verfügbar macht __prototype__), um festzustellen, dass eine bestimmte Kennung nicht an ein Objekt oder etwas in seiner Prototypenkette angehängt wurde.

Wenn Sie nach einer Immobilie suchen, dann "NEIN". Sie wollen:

if ('prop' in obj) { }

Im Allgemeinen sollte es Ihnen egal sein, ob die Eigenschaft vom Prototyp oder vom Objekt stammt oder nicht.

Da Sie jedoch in Ihrem Beispielcode 'key' verwendet haben, scheint es, als würden Sie das Objekt als Hash behandeln. In diesem Fall wäre Ihre Antwort sinnvoll. Alle Hashes-Schlüssel wären Eigenschaften im Objekt, und Sie vermeiden die zusätzlichen Eigenschaften, die der Prototyp mit sich bringt.

John Resigs Antwort war sehr umfassend, aber ich dachte, es sei nicht klar. Besonders wenn man "'prop' in obj" verwendet.

Verwenden Sie zum Testen einfacher Objekte: if (obj[x] !== undefined)

Wenn Sie nicht wissen, welcher Objekttyp verwendet wird: if (obj.hasOwnProperty(x))

Alle anderen Optionen sind langsamer.

Einzelheiten

Leistungsbewertung von 100.000.000 Zyklen unter Nodejs anhand der 5 von anderen hier vorgeschlagenen Optionen:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

Die Auswertung zeigt, dass wir nicht die übliche Form verwenden sollten, es sei denn, wir möchten speziell die Prototypkette des Objekts sowie das Objekt selbst überprüfen: if (X in Obj)... Sie ist je nach Anwendungsfall zwei- bis sechsmal langsamer

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

Fazit: Wenn Ihr Objekt nicht unbedingt ein einfaches Objekt ist und Sie vermeiden möchten, die Prototypkette des Objekts zu überprüfen und sicherzustellen, dass x direkt Obj gehört, verwenden Sie 'if (obj.hasOwnProperty (x)) ...'.

Andernfalls, wenn Sie ein einfaches Objekt verwenden und sich keine Sorgen um die Prototypkette des Objekts machen, verwenden Sie if (typeof(obj[x]) !== 'undefined')... ist die der sicherste und schnellste Weg.

Wenn Sie ein einfaches Objekt als Hash-Tabelle verwenden und niemals etwas Versautes tun, würde ich es verwenden if (obj[x])... da ich es viel lesbarer finde.

Habe Spaß.

Ja, das ist es :) Ich denke, Sie können auch tun, Object.prototype.hasOwnProperty.call(x, 'key')was auch funktionieren sollte, wenn xeine Eigenschaft namens hasOwnProperty:)

Aber das prüft auf eigene Eigenschaften. Wenn Sie überprüfen möchten, ob eine Eigenschaft vorhanden ist, die möglicherweise auch vererbt wird, können Sie diese verwenden typeof x.foo != 'undefined'.

if (typeof x.key != "undefined") {

}

weil

if (x.key)

schlägt fehl , wenn x.keyEntschlüssen zu false(Beispiel für, x.key = "").

Sie können auch das ES6- ReflectObjekt verwenden :

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

Dokumentation zu MDN für Reflect.hasfinden Sie hier .

Die statische Reflect.has()Methode funktioniert wie der in-Operator als Funktion.

OK, es sieht so aus, als hätte ich die richtige Antwort, es sei denn, Sie möchten keine geerbten Eigenschaften:

if (x.hasOwnProperty('key'))

Hier sind einige andere Optionen, um geerbte Eigenschaften einzuschließen:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

Tun Sie dies nicht, es object.hasOwnProperty(key))ist wirklich schlecht, da diese Methoden möglicherweise durch Eigenschaften des betreffenden Objekts überschattet werden - berücksichtigen Sie { hasOwnProperty: false }- oder das Objekt ein Nullobjekt sein kann(Object.create(null)) .

Der beste Weg ist zu tun Object.prototype.hasOwnProperty.call(object, key)oder:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

Ein anderer relativ einfacher Weg ist die Verwendung Object.keys. Dies gibt ein zurück, arraywas bedeutet, dass Sie alle Funktionen eines Arrays erhalten.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

Obwohl wir uns in einer Welt mit großartiger Browserunterstützung befinden. Da diese Frage so alt ist, dachte ich, ich würde Folgendes hinzufügen: Dies ist ab JS v1.8.5 sicher zu verwenden

hasOwnProperty "kann verwendet werden, um zu bestimmen, ob ein Objekt die angegebene Eigenschaft als direkte Eigenschaft dieses Objekts hat. Im Gegensatz zum Operator in überprüft diese Methode die Prototypkette des Objekts nicht."

Wahrscheinlich möchten Sie für Ihre Frage keine hasOwnProperty verwenden, die bestimmt, ob die Eigenschaft als direkt an das Objekt selbst angehängt vorhanden ist.

Wenn Sie feststellen möchten, ob die Eigenschaft in der Prototypkette vorhanden ist, in der Sie hauptsächlich verwenden möchten, z.

if( prop in object ){ // do something }

Ich hoffe das hilft.

Mit dem Risiko eines massiven Downvotings ist hier eine weitere Option für einen bestimmten Fall. :) :)

Wenn Sie ein Mitglied auf ein Objekt testen möchten und wissen möchten, ob es auf etwas anderes als Folgendes festgelegt wurde:

• ''
• falsch
• Null
• nicht definiert
• 0 ...

dann können Sie verwenden:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

ECMA Script 6 Lösung mit Reflect. Erstellen Sie einen Wrapper wie:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg

Es gibt die Methode "hasOwnProperty" für das Objekt, es wird jedoch nicht empfohlen, diese Methode direkt aufzurufen, da das Objekt manchmal null ist oder eine Eigenschaft für das Objekt vorhanden ist, z. { hasOwnProperty: false }

Ein besserer Weg wäre also:

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

Sie können die folgenden Ansätze verwenden:

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

Der Unterschied zwischen den folgenden Ansätzen ist wie folgt:

1. Im 1. und 3. Ansatz suchen wir nicht nur nach Objekten, sondern auch nach deren Prototypenketten. Wenn das Objekt nicht über die Eigenschaft verfügt, die Eigenschaft jedoch in der Prototypenkette vorhanden ist, wird true angegeben.

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

2. Der zweite Ansatz prüft nur seine eigenen Eigenschaften. Ex -

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

3. Der Unterschied zwischen dem ersten und dem dritten ist, wenn es eine Eigenschaft gibt, deren Wert undefiniert ist, wird der dritte Ansatz false geben, während der erste true ergibt.

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

Sie müssen die Methode verwenden object.hasOwnProperty(property). Es gibt true zurück, wenn das Objekt die Eigenschaft hat, und false, wenn das Objekt dies nicht tut.

Wenn der zu überprüfende Schlüssel in einer Variablen gespeichert ist , können Sie ihn folgendermaßen überprüfen:

x = {'key': 1};
y = 'key';
x[y];

Warum Dinge zu kompliziert machen, wenn Sie Folgendes tun können:

var isProperty =  (objectname.keyname || "") ? true : false;

Einfach und klar für die meisten Fälle ...