Wie überprüfe ich, ob das Objekt Eigenschaften in JavaScript hat?

Vorausgesetzt, ich erkläre

var ad = {}; 

Wie kann ich überprüfen, ob dieses Objekt benutzerdefinierte Eigenschaften enthält?

Sie können die Eigenschaften Ihres Objekts wie folgt durchlaufen:

for(var prop in ad) {
    if (ad.hasOwnProperty(prop)) {
        // handle prop as required
    }
}

Es ist wichtig, die zu verwenden hasOwnProperty() Methode zu verwenden, um festzustellen, ob das Objekt die angegebene Eigenschaft als direkte Eigenschaft hat und nicht von der Prototypkette des Objekts geerbt wird.

Bearbeiten

Aus den Kommentaren: Sie können diesen Code in eine Funktion einfügen und ihn als falsch zurückgeben, sobald er den Teil erreicht, in dem sich der Kommentar befindet

Leistungstest

Test Of Object.Keys vs For..In Beim Testen auf Eigenschaften

Mit der integrierten Object.keysMethode können Sie eine Liste der Schlüssel für ein Objekt abrufen und dessen Länge testen.

var x = {};
// some code where value of x changes and than you want to check whether it is null or some object with values

if(Object.keys(x).length > 0){
 // Your code here if x has some properties  
}

Was ist mit einer einfachen Funktion?

function isEmptyObject(obj) {
  for(var prop in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, prop)) {
      return false;
    }
  }
  return true;
}

isEmptyObject({}); // true
isEmptyObject({foo:'bar'});  // false

Der hasOwnPropertyMethodenaufruf direkt auf dem Object.prototypedient nur dazu, etwas mehr Sicherheit zu bieten. Stellen Sie sich Folgendes mit einem normalen obj.hasOwnProperty(...)Aufruf vor:

isEmptyObject({hasOwnProperty:'boom'});  // false

Hinweis: _{(für die Zukunft)} Die obige Methode basiert auf der for...inAnweisung, und diese Anweisung iteriert nur über aufzählbare Eigenschaften. Im derzeit am weitesten verbreiteten ECMAScript-Standard (3. Ausgabe) hat der Programmierer keine Möglichkeit, nicht aufzählbare Eigenschaften zu erstellen .

Dies hat sich jedoch jetzt mit ECMAScript 5th Edition geändert , und wir können nicht aufzählbare, nicht beschreibbare oder nicht löschbare Eigenschaften erstellen, sodass die oben beschriebene Methode fehlschlagen kann , z.

var obj = {};
Object.defineProperty(obj, 'test', { value: 'testVal', 
  enumerable: false,
  writable: true,
  configurable: true
});
isEmptyObject(obj); // true, wrong!!
obj.hasOwnProperty('test'); // true, the property exist!!

Eine ECMAScript 5-Lösung für dieses Problem wäre:

function isEmptyObject(obj) {
  return Object.getOwnPropertyNames(obj).length === 0;
}

Das Object.getOwnPropertyNames Methode gibt ein Arraydie Namen enthält alle die eigenen Eigenschaften eines Objekts, zählbare oder nicht , dieses Verfahren wird nun durch Browser - Anbieter implementiert, es ist bereits auf dem Chrome 5 Beta und die neuesten WebKit Nightly Builds.

Object.defineProperty ist auch in diesen Browsern und den neuesten Firefox 3.7 Alpha-Versionen verfügbar.

Mit jQuery können Sie Folgendes verwenden:

$.isEmptyObject(obj); // Returns: Boolean

Ab jQuery 1.4 überprüft diese Methode sowohl Eigenschaften des Objekts selbst als auch Eigenschaften, die von Prototypen geerbt wurden (da hasOwnProperty nicht verwendet wird).

Mit ECMAScript 5th Edition in modernen Browsern (IE9 +, FF4 +, Chrome5 +, Opera12 +, Safari5 +) können Sie die integrierte Object.keys- Methode verwenden:

var obj = { blah: 1 };
var isEmpty = !Object.keys(obj).length;

Oder einfaches altes JavaScript:

var isEmpty = function(obj) {
               for(var p in obj){
                  return false;
               }
               return true;
            };

Die neuesten Browser (und node.js) unterstützen Object.keys (), das ein Array mit allen Schlüsseln in Ihrem Objektliteral zurückgibt, sodass Sie Folgendes tun können:

var ad = {}; 
Object.keys(ad).length;//this will be 0 in this case

Browserunterstützung: Firefox 4, Chrome 5, Internet Explorer 9, Opera 12, Safari 5

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

Wenn Sie underscore.js verwenden, können Sie die Funktion _.isEmpty verwenden:

var obj = {};
var emptyObject = _.isEmpty(obj);

Wenn Sie bereit sind, lodash zu verwenden , können Sie die someMethode verwenden.

_.some(obj) // returns true or false

Siehe dieses kleine jsbin- Beispiel

for (var hasProperties in ad) break;
if (hasProperties)
    ... // ad has properties

Wenn Sie sicher sein und nach Objektprototypen suchen müssen (diese werden von bestimmten Bibliotheken hinzugefügt und sind dort nicht standardmäßig vorhanden):

var hasProperties = false;
for (var x in ad) {
    if (ad.hasOwnProperty(x)) {
        hasProperties = true;
        break;
    }
}
if (hasProperties)
    ... // ad has properties

for(var memberName in ad)
{
  //Member Name: memberName
  //Member Value: ad[memberName]
}

Member bedeutet Member-Eigenschaft, Member-Variable, wie auch immer Sie sie nennen möchten> _>

Der obige Code gibt ALLES zurück, einschließlich toString ... Wenn Sie nur sehen möchten, ob der Prototyp des Objekts erweitert wurde:

var dummyObj = {};  
for(var memberName in ad)
{
  if(typeof(dummyObj[memberName]) == typeof(ad[memberName])) continue; //note A
  //Member Name: memberName
  //Member Value: ad[memberName]

}

Hinweis A: Wir prüfen, ob das Mitglied des Dummy-Objekts denselben Typ wie das Mitglied unseres Testobjekts hat. Wenn es sich um eine Erweiterung handelt, sollte der Elementtyp des Dummyobjekts "undefiniert" sein.

var hasAnyProps = false; for (var key in obj) { hasAnyProps = true; break; }
// as of this line hasAnyProps will show Boolean whether or not any iterable props exist

Einfach, funktioniert in jedem Browser und obwohl es technisch gesehen eine Schleife für alle Schlüssel des Objekts ist , durchläuft es NICHT alle ... entweder gibt es 0 und die Schleife läuft nicht oder es gibt einige und sie bricht nach der ersten eins (weil wir nur prüfen, ob es JEDEN gibt ... warum also weitermachen?)

Sehr späte Antwort, aber so könnten Sie mit Prototypen umgehen.

Array.prototype.Any = function(func) {
    return this.some(func || function(x) { return x });
}

Object.prototype.IsAny = function() {
    return Object.keys(this).Any();
}

Wenn Sie sicher sind, dass das Objekt benutzerdefiniert ist, können Sie am einfachsten feststellen, ob UDO leer ist: Der folgende Code:

isEmpty=
/*b.b Troy III p.a.e*/
function(x,p){for(p in x)return!1;return!0};

Obwohl diese Methode (von Natur aus) deduktiv ist, ist sie die schnellste und schnellste.

a={};
isEmpty(a) >> true

a.b=1
isEmpty(a) >> false 

ps :! nicht für browserdefinierte Objekte verwenden.

Späte Antwort, aber einige Frameworks behandeln Objekte als Aufzählungen. Daher kann bob.js dies folgendermaßen tun:

var objToTest = {};
var propertyCount = bob.collections.extend(objToTest).count();

Sie können Folgendes verwenden:

Doppelknall !! Immobiliensuche

var a = !![]; // true
var a = !!null; // false

hasOwnProperty Dies ist etwas, das ich verwendet habe:

var myObject = {
  name: 'John',
  address: null
};
if (myObject.hasOwnProperty('address')) { // true
  // do something if it exists.
}

JavaScript hat jedoch beschlossen, den Namen der Methode nicht zu schützen, damit er manipuliert werden kann.

var myObject = {
  hasOwnProperty: 'I will populate it myself!'
};

Requisite in myObject

var myObject = {
  name: 'John',
  address: null,
  developer: false
};
'developer' in myObject; // true, remember it's looking for exists, not value.

Art der

if (typeof myObject.name !== 'undefined') {
  // do something
}

Es wird jedoch nicht nach null gesucht.

Ich denke, das ist der beste Weg.

im Betreiber

var myObject = {
  name: 'John',
  address: null
};

if('name' in myObject) {
  console.log("Name exists in myObject");
}else{
  console.log("Name does not exist in myObject");
}

Ergebnis:

Name existiert in myObject

Hier ist ein Link, der detaillierter auf den Operator in eingeht: Feststellen, ob eine Objekteigenschaft vorhanden ist

ES6- Funktion

/**
 * Returns true if an object is empty.
 * @param  {*} obj the object to test
 * @return {boolean} returns true if object is empty, otherwise returns false
 */
const pureObjectIsEmpty = obj => obj && obj.constructor === Object && Object.keys(obj).length === 0

Beispiele:

let obj = "this is an object with String constructor"
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {}
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = []
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = [{prop:"value"}]
console.log(pureObjectIsEmpty(obj)) // empty? true

obj = {prop:"value"}
console.log(pureObjectIsEmpty(obj)) // empty? false

Wie wäre es damit?

var obj = {},
var isEmpty = !obj;
var hasContent = !!obj