it-swarm.com.de

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

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

Erwägen:

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

Ist das der beste Weg, dies zu tun?

1272
sheats

Ich bin wirklich verwirrt von den Antworten, die gegeben wurden - die meisten von ihnen sind einfach falsch. Natürlich können Sie Objekteigenschaften mit undefinierten, Null- oder Falschwerten haben. Wenn Sie die Eigenschaftsprüfung einfach auf typeof this[property] reduzieren oder sogar noch x.key, werden Sie völlig irreführende Ergebnisse erzielen.

Das hängt davon ab, wonach Sie suchen. Wenn Sie wissen möchten, ob ein Objekt physisch eine Eigenschaft enthält (und es nicht von irgendwo in der Prototypkette kommt), ist object.hasOwnProperty der richtige Weg. Alle modernen Browser unterstützen es. (In älteren Versionen von Safari - 2.0.1 und älteren Versionen - fehlte es. Diese Versionen des Browsers werden jedoch selten mehr verwendet.)

Wenn Sie nach einem Objekt suchen, das eine Eigenschaft enthält, die iterierbar ist (wenn Sie die Eigenschaften des Objekts durchlaufen, wird es angezeigt), wird Folgendes ausgeführt: prop in object gibt Ihnen den gewünschten Effekt.

Da hasOwnProperty wahrscheinlich das ist, was Sie wollen, und wenn Sie eine Fallback-Methode in Betracht ziehen, 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 hasOwnProperty mit einer Einschränkung: Es kann nicht zwischen Fällen unterschieden werden, in denen eine identische Eigenschaft im Prototyp und in der Instanz vorhanden ist. Es wird lediglich davon ausgegangen, dass es vom Prototyp stammt. Abhängig von Ihrer Situation können Sie die Einstellung nachträglicher oder strenger machen, aber dies sollte zumindest hilfreich sein.

1270
John Resig

Mit Underscore.js oder ( noch besser ) lodash :

_.has(x, 'key');

Welcher Aufruf Object.prototype.hasOwnProperty, aber (a) ist kürzer als der Typ, und (b) verwendet "einen sicheren Verweis auf hasOwnProperty" (d. H. Er funktioniert auch, wenn hasOwnProperty überschrieben wird).

Lodash definiert insbesondere _.has als:

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

Anmerkung: Folgendes ist heutzutage dank des strikten Modus und hasOwnProperty weitgehend überholt. Die richtige Lösung besteht darin, den strikten Modus zu verwenden und mit obj.hasOwnProperty auf das Vorhandensein einer Eigenschaft zu prüfen. Diese Antwort ist älter als beides, zumindest so weit verbreitet (ja, es ist so alt). Nehmen Sie das Folgende als historische Notiz.


Bedenken Sie, dass undefined (leider) nicht ​​ein reserviertes Wort in JavaScript ist, wenn Sie den strikten Modus nicht 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 übliche Alternative besteht darin, sicherzustellen, dass undefinedtatsächlich undefiniert ist, z. indem Sie den Code in eine Funktion einfügen, die einen zusätzlichen Parameter namens undefined akzeptiert, dem kein Wert übergeben wurde. 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 …
})();
118
Konrad Rudolph

Wie wäre es mit?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}
105
Whisher
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 erwähnt by Konrad Rudolph und Armin Ronacher wäre:

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

Mit dem Operator in 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 mit einer for - in-Schleife durchlaufen und dann nach der bestimmten Eigenschaft suchen:

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

Sie müssen prüfen, ob diese Objekteigenschaft auflistbar ist oder nicht, da nicht auflösbare Eigenschaften nicht in einer for-in-Schleife angezeigt werden. Wenn die Enumerable-Eigenschaft eine nicht aufzählbare Eigenschaft des Prototyps spiegelt, wird sie in Internet Explorer 8 und früheren Versionen nicht angezeigt.

Wenn Sie eine Liste aller Instanzeigenschaften erhalten möchten, unabhängig davon, ob sie aufgelistet werden können oder nicht, können Sie sie verwenden

Object.getOwnPropertyNames(x);

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

Schließlich können Sie den typeof-Operator 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 undefined 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 undefined gesetzt ist. In diesem Fall würde typeof x.key immer noch true zurückgeben (obwohl der Schlüssel ist) noch im Objekt).

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

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

Dies sollte funktionieren, wenn der Schlüssel für das x-Objekt nicht speziell auf undefined festgelegt wurde

33
goonerify

Lassen Sie uns hier einige Verwirrung durchbrechen. Lassen Sie uns zunächst vereinfachen, indem Sie davon ausgehen, dass hasOwnProperty bereits vorhanden ist. Dies trifft auf die große Mehrheit der derzeit verwendeten Browser zu.

hasOwnProperty gibt true zurück, wenn der übergebene Attributname dem Objekt hinzugefügt wurde. Sie ist völlig unabhängig von dem tatsächlich zugewiesenen Wert, der genau undefined sein kann.

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 Prototypkette ein Attribut mit dem Wert undefined hat. hasOwnProperty ist falsch und !== undefined. for..in listet es trotzdem in der Aufzählung auf.

Unter dem Strich gibt es keine Cross-Browser-Methode (da Internet Explorer __prototype__ nicht verfügbar macht), um festzustellen, dass ein bestimmter Bezeichner nicht an ein Objekt oder an etwas in seiner Prototypkette angehängt wurde.

26
AnthonyWJones

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

if ('prop' in obj) { }

Im Allgemeinen sollten Sie sich nicht darum kümmern, ob die Eigenschaft vom Prototyp oder vom Objekt stammt.

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. Bei allen Hash-Schlüsseln handelt es sich um Eigenschaften im Objekt, und Sie vermeiden die zusätzlichen Eigenschaften, die vom Prototyp hinzugefügt werden.

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

17
Gerard ONeill

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

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

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

}

Weil

if (x.key)

schlägt fehl, wenn x.key in false aufgelöst wird (beispielsweise x.key = "").

12
werehamster

Sie können auch das ES6-Objekt Reflect verwenden:

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

Dokumentation zu MDN für Reflect.has finden Sie hier hier .

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

10
Wilt

Zum Testen einfacher Objekte verwenden Sie: if (obj[x] !== undefined)

Wenn Sie nicht wissen, um welchen Objekttyp es sich handelt, verwenden Sie: if (obj.hasOwnProperty(x))

Alle anderen Optionen sind langsamer.

Einzelheiten

Leistungsbewertung von 100.000.000 Zyklen unter Nodejs zu den 5 Optionen, die von anderen hier vorgeschlagen wurden:

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 sagt uns, dass wir, wenn wir nicht ausdrücklich die Prototypkette des Objekts sowie das Objekt selbst überprüfen möchten, nicht die übliche Form verwenden sollten: if (X in Obj)...Je nach Verwendung ist sie zwei bis sechs Mal langsamer Fall 

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 Obj nicht unbedingt ein einfaches Objekt ist und Sie die Prüfung der Prototypkette des Objekts vermeiden möchten und um sicherzustellen, dass x direkt im Besitz von Obj ist, verwenden Sie 'if (obj.hasOwnProperty (x)) ...'.

Ansonsten, wenn Sie ein einfaches Objekt verwenden und sich nicht um die Prototypkette des Objekts kümmern, ist die Verwendung von if (typeof(obj[x]) !== 'undefined')... der sicherste und schnellste Weg. 

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

Habe Spaß.

10
davidhadas

OK, anscheinend hatte ich die richtige Antwort, es sei denn, Sie möchten keine geerbten Eigenschaften haben:

if (x.hasOwnProperty('key'))

Hier einige weitere Optionen, um geerbte Eigenschaften einzuschließen:

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

if (x.key !== undefined)
7
sheats

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

Wahrscheinlich möchten Sie für has, was Ihre Frage scheint, hasOwnProperty nicht verwenden, die bestimmt, ob die Eigenschaft als direkt am Objekt selbst , angehängt vorhanden ist.

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

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

Ich hoffe das hilft.

5
rogopag

Eine andere relativ einfache Möglichkeit ist die Verwendung von Object.keys . Dies gibt eine array zurück, dh Sie erhalten alle Funktionen eines Arrays.

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 sicher ab JS v1.8.5

4
Jamie Hutber

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

Am besten tun Sie 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));
3
Abdullah Danyal

Mit der Gefahr eines massiven Downvoting ist hier eine weitere Option für einen bestimmten Fall. :)

Wenn Sie für ein Objekt auf ein Objekt testen möchten und wissen möchten, ob es auf etwas anderes gesetzt wurde als:

  • ''
  • false
  • null
  • undefined
  • 0 ...

dann kannst du verwenden:

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

ECMAScript 6-Lösung mit Reflektieren. Wrapper erstellen 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
2
Harm

Es gibt eine Methode "hasOwnProperty" für ein Objekt, es wird jedoch nicht empfohlen, diese Methode direkt aufzurufen, da das Objekt manchmal Null ist oder eine Eigenschaft für ein Objekt wie folgt vorhanden ist: { hasOwnProperty: false }

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

2

Warum zu kompliziert, wenn Sie können:

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

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

1
Alex

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

1
John Anisere

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

Die folgenden Ansätze unterscheiden sich wie folgt: 

  1. Im ersten und dritten Ansatz suchen wir nicht nur in Objekten, sondern auch in der Prototyp-Kette. Wenn das Objekt die Eigenschaft nicht besitzt, aber Die Eigenschaft in seiner Prototypkette vorhanden ist, wird es True geben. 

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

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

  1. Der zweite Ansatz prüft nur die eigenen Eigenschaften. Ex - 

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

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

  1. Der Unterschied zwischen dem ersten und dem dritten Wert besteht darin, dass bei einer Eigenschaft, deren Wert undefiniert ist, der dritte Ansatz falsch ist, während zuerst wahr angegeben wird. 

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

0
Komal Bansal

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

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