Nach einer AJAX-Anforderung gibt meine Anwendung manchmal ein leeres Objekt zurück, z.

var a = {};

Wie kann ich überprüfen, ob dies der Fall ist?

ECMA 5+ :

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.keys(obj).length === 0 && obj.constructor === Object

Beachten Sie jedoch, dass dadurch ein unnötiges Array erstellt wird (der Rückgabewert von keys).

Pre-ECMA 5:

function isEmpty(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      return false;
    }
  }

  return JSON.stringify(obj) === JSON.stringify({});
}

jQuery :

jQuery.isEmptyObject({}); // true

lodash :

_.isEmpty({}); // true

Unterstreichen :

_.isEmpty({}); // true

Hoek

Hoek.deepEqual({}, {}); // true

ExtJS

Ext.Object.isEmpty({}); // true

AngularJS (Version 1)

angular.equals({}, {}); // true

Ramda

R.isEmpty({}); // true

Es gibt keine einfache Möglichkeit, dies zu tun. Sie müssen die Eigenschaften explizit durchlaufen:

function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return true;
}

Wenn ECMAScript 5-Unterstützung verfügbar ist, können Sie Object.keys()stattdessen Folgendes verwenden :

function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}

Für diejenigen unter Ihnen, die das gleiche Problem haben, aber jQuery verwenden, können Sie jQuery.isEmptyObject verwenden .

Dies ist meine bevorzugte Lösung:

var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty

Sie können Underscore.js verwenden .

_.isEmpty({}); // true

if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

siehe http://bencollier.net/2011/04/javascript-is-an-object-empty/

Wie wäre es mit JSON.stringify? Es ist fast in allen modernen Browsern verfügbar.

function isEmptyObject(obj){
    return JSON.stringify(obj) === '{}';
}

Ich bin gerade in eine ähnliche Situation geraten. Ich wollte JQuery nicht verwenden und wollte dies mit reinem Javascript tun.

Und was ich tat, war, die folgende Bedingung zu verwenden, und es funktionierte für mich.

var obj = {};
if(JSON.stringify(obj) === '{}') { //This will check if the object is empty
   //Code here..
}

Verwenden Sie für nicht gleich: JSON.stringify(obj) !== '{}'

Schauen Sie sich diese JSFiddle an

Alte Frage, hatte aber gerade das Problem. Das Einschließen von JQuery ist keine gute Idee, wenn Sie nur überprüfen möchten, ob das Objekt nicht leer ist. Wenn Sie stattdessen tief in den Code von JQuery eintauchen , erhalten Sie die Antwort:

function isEmptyObject(obj) {
    var name;
    for (name in obj) {
        if (obj.hasOwnProperty(name)) {
            return false;
        }
    }
    return true;
}

Es gibt eine einfache Möglichkeit, wenn Sie einen neueren Browser verwenden. Object.keys(obj).length == 0

Performance

Heute 2020.01.17 führe ich Tests auf MacOs HighSierra 10.13.6 unter Chrome v79.0, Safari v13.0.4 und Firefox v72.0 für ausgewählte Lösungen durch.

Schlussfolgerungen

• Lösungen basierend auf for-in(A, J, L, M) sind am schnellsten
• Lösungen basierend auf JSON.stringify(B, K) sind langsam
• überraschenderweise ist auch die auf Object(N) basierende Lösung langsam

Einzelheiten

Unten im Snippet werden 15 Lösungen vorgestellt. Wenn Sie einen Leistungstest auf Ihrem Computer ausführen möchten, klicken Sie HIER .

var log = (s,f) => console.log(`${s} --> {}:${f({})}  {k:2}:${f({k:2})}`);

function A(obj) {
  for(var i in obj) return false; 
  return true;
}

function B(obj) {
  return JSON.stringify(obj) === '{}';
}

function C(obj) {
  return Object.keys(obj).length === 0;
}

function D(obj) {
  return Object.entries(obj).length === 0;
}

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

function F(obj) {
  return Object.keys(obj).length === 0 && obj.constructor === Object;
}

function G(obj) {
  return typeof obj === "undefined" || !Boolean(Object.keys(obj)[0]);
}

function H(obj) {
  return Object.entries(obj).length === 0 && obj.constructor === Object;
}

function I(obj) {
  return Object.values( obj  ).every( val => typeof val === "undefined" );
}

function J(obj) {
  for (const key in obj) {
    if (hasOwnProperty.call(obj, key)) {
      return false
    }
  }
  return true;
}

function K(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      return false;
    }
  }

  return JSON.stringify(obj) == JSON.stringify({});
}

function L(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop))
      return false;
  }

  return true;
}

function M(obj) {
  for (var k in obj)
  { 
    if ( obj.hasOwnProperty(k) )
    { 
      return false;
    } 
  }
  return true; 
}

function N(obj) {
  return Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype; 
}

function O(obj) {
  return !(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(obj).length != 0 : (function(){for(var key in obj) break; return (key != null) && (key != undefined);})())
}

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);

Die Verwendung von Object.keys (obj) .length (wie oben für ECMA 5+ vorgeschlagen) ist für leere Objekte zehnmal langsamer! Halten Sie sich an die Option der alten Schule (für ... in).

Getestet unter Node, Chrome, Firefox und IE 9 wird deutlich, dass für die meisten Anwendungsfälle:

• (für ... in ...) ist die schnellste Option!
• Object.keys (obj) .length ist für leere Objekte zehnmal langsamer
• JSON.stringify (obj) .length ist immer die langsamste (nicht überraschend)
• Object.getOwnPropertyNames (obj) .length dauert länger als Object.keys (obj) .length kann auf einigen Systemen viel länger sein.

Fazit: Verwenden Sie:

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

oder

function isEmpty(obj) {
   for (var x in obj) { if (obj.hasOwnProperty(x))  return false; }
   return true;
}

Detaillierte Testergebnisse und Testcode finden Sie unter Ist das Objekt leer?

Sie können die Anzahl der Objektschlüssel überprüfen:

if (Object.keys(a).length > 0) {
    // not empty
}

1. Nur eine Problemumgehung. Kann Ihr Server eine spezielle Eigenschaft generieren, wenn keine Daten vorliegen?

   Zum Beispiel:

   var a = {empty:true};

   Dann können Sie es einfach in Ihrem AJAX-Rückrufcode überprüfen.

2. Eine andere Möglichkeit, dies zu überprüfen:

   if (a.toSource() === "({})")  // then 'a' is empty

BEARBEITEN : Wenn Sie eine JSON-Bibliothek (z. B. JSON.js) verwenden, können Sie die Funktion JSON.encode () ausprobieren und das Ergebnis anhand einer leeren Wertzeichenfolge testen.

Ich habe eine vollständige Funktion erstellt, um festzustellen, ob das Objekt leer ist.

Es verwendet Object.keysvon ECMAScript 5 (ES5) Funktionalität , wenn möglich , die beste Leistung (siehe erreichen Kompatibilitätstabelle ) und Fallbacks auf den meisten kompatiblen Ansatz für ältere Motoren (Browser).

Lösung

/**
 * Returns true if specified object has no properties,
 * false otherwise.
 *
 * @param {object} object
 * @returns {boolean}
 */
function isObjectEmpty(object)
{
    if ('object' !== typeof object) {
        throw new Error('Object must be specified.');
    }

    if (null === object) {
        return true;
    }

    if ('undefined' !== Object.keys) {
        // Using ECMAScript 5 feature.
        return (0 === Object.keys(object).length);
    } else {
        // Using legacy compatibility mode.
        for (var key in object) {
            if (object.hasOwnProperty(key)) {
                return false;
            }
        }
        return true;
    }
}

Hier ist das Wesentliche für diesen Code.

Und hier ist die JSFiddle mit Demonstration und einem einfachen Test.

Ich hoffe es wird jemandem helfen. Prost!

Ich benutze das.

function isObjectEmpty(object) {
  var isEmpty = true;
  for (keys in object) {
     isEmpty = false;
     break; // exiting since we found that the object is not empty
  }
  return isEmpty;
}

Z.B:

var myObject = {}; // Object is empty
var isEmpty  = isObjectEmpty(myObject); // will return true;

// populating the object
myObject = {"name":"John Smith","Address":"Kochi, Kerala"}; 

// check if the object is empty
isEmpty  = isObjectEmpty(myObject); // will return false;

von hier

Aktualisieren

ODER

Sie können die jQuery-Implementierung von isEmptyObject verwenden

function isEmptyObject(obj) {
  var name;
  for (name in obj) {
    return false;
  }
  return true;
}

Das folgende Beispiel zeigt, wie Sie testen, ob ein JavaScript-Objekt leer ist. Wenn mit leer gemeint ist, bedeutet dies, dass es keine eigenen Eigenschaften hat.

Das Skript funktioniert unter ES6.

const isEmpty = (obj) => {
    if (obj === null ||
        obj === undefined ||
        Array.isArray(obj) ||
        typeof obj !== 'object'
    ) {
        return true;
    }
    return Object.getOwnPropertyNames(obj).length === 0;
};
console.clear();
console.log('-----');
console.log(isEmpty(''));           // true
console.log(isEmpty(33));           // true
console.log(isEmpty([]));           // true
console.log(isEmpty({}));           // true
console.log(isEmpty({ length: 0, custom_property: [] })); // false
console.log('-----');
console.log(isEmpty('Hello'));      // true
console.log(isEmpty([1, 2, 3]));    // true
console.log(isEmpty({ test: 1 }));  // false
console.log(isEmpty({ length: 3, custom_property: [1, 2, 3] })); // false
console.log('-----');
console.log(isEmpty(new Date()));   // true
console.log(isEmpty(Infinity));     // true
console.log(isEmpty(null));         // true
console.log(isEmpty(undefined));    // true

Gemäß der ES2017- Spezifikation für Object.entries () ist die Überprüfung mit jedem modernen Browser einfach.

Object.entries({}).length === 0

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

jQuery hat isEmptyObject()für diesen Fall eine spezielle Funktion :

jQuery.isEmptyObject({}) // true
jQuery.isEmptyObject({ foo: "bar" }) // false

Lesen Sie mehr unter http://api.jquery.com/jQuery.isEmptyObject/

Ich würde prüfen, ob es mindestens einen Schlüssel hat. Das würde ausreichen, um mir zu sagen, dass es nicht leer ist.

typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])

Unter der Haube verwenden alle leeren Prüfmethoden in allen Bibliotheken die Logik der Objektschlüsselprüfung. Es ist eine seltsame Art, es verständlich zu machen, die Sie in eine hier beschriebene Methode einfügen können .

for(key in obj){
   //your work here.
 break;
}

Was sich in ES5 entwickelt hat , können Sie jetzt einfach gesagt die Schlüssellänge des Objekts überprüfen, indem Sie eine Object.KeysMethode verwenden, die Ihr Objekt als Parameter verwendet:

if(Object.keys(obj).length > 0){
 //do your work here
}

Oder wenn Sie Lodash verwenden (müssen Sie sein) dann.

 _.isEmpty(obj) //==true or false

Sie können diesen einfachen Code verwenden, der weder jQuery noch andere Bibliotheken verwendet hat

var a=({});

//check is an empty object
if(JSON.stringify(a)=='{}') {
    alert('it is empty');
} else {
    alert('it is not empty');
}

Die JSON- Klasse und ihre Funktionen ( Parse und Stringify ) sind sehr nützlich, haben jedoch einige Probleme mit IE7 , die Sie mit diesem einfachen Code beheben können: http://www.json.org/js.html .

Anderer einfacher Weg (einfachster Weg):
Sie können diesen Weg ohne Verwendung von jQuery oder JSON- Objekt verwenden.

var a=({});

function isEmptyObject(obj) {
    if(typeof obj!='object') {
        //it is not object, so is not empty
        return false;
    } else {
        var x,i=0;
        for(x in obj) {
            i++;
        }
        if(i>0) {
            //this object has some properties or methods
            return false;
        } else {
            //this object has not any property or method
            return true;
        }
    }
}

alert(isEmptyObject(a));    //true is alerted

Der beste Weg, den ich gefunden habe:

function isEmpty(obj)
{
    if (!obj)
    {
        return true;
    }

    if (!(typeof(obj) === 'number') && !Object.keys(obj).length)
    {
        return true;
    }

    return false;
}

Funktioniert für:

    t1: {} -> true
    t2: {0:1} -: false
    t3: [] -> true
    t4: [2] -> false
    t5: null -> true
    t6: undefined -> true
    t7: "" -> true
    t8: "a" -> false
    t9: 0 -> true
    t10: 1 -> false

Meine Einstellung:

function isEmpty(obj) {
    return !Object.keys(obj).length > 0;
}

var a = {a:1, b:2}
var b = {}

console.log(isEmpty(a)); // false
console.log(isEmpty(b)); // true

Ich glaube nicht, dass Object.keys()derzeit alle Browser implementiert sind .

Wenn jQuery und der Webbrowser nicht verfügbar sind, gibt es in underscore.js auch eine isEmpty-Funktion.

_.isEmpty({}) // returns true

Außerdem wird nicht angenommen, dass der Eingabeparameter ein Objekt ist. Für eine Liste oder Zeichenfolge oder undefiniert wird auch die richtige Antwort angezeigt.

Vorbehalt! Achten Sie auf die Einschränkungen von JSON.

javascript:
  obj={  f:function(){}  };
  alert( "Beware!! obj is NOT empty!\n\nobj = {  f:function(){}  }" + 
               "\n\nJSON.stringify( obj )\n\nreturns\n\n" +
                        JSON.stringify( obj ) );

Anzeigen

    In acht nehmen!! obj ist NICHT leer!

    obj = {f: function () {}}

    JSON.stringify (obj)

    kehrt zurück

    {}

Die richtige Antwort ist:

const isEmptyObject = obj =>
  Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype;

Dies überprüft, dass:

• Das Objekt hat keine eigenen Eigenschaften (unabhängig von der Aufzählbarkeit).
• Das Objekt hat keine eigenen Eigenschaftssymbole.
• Der Prototyp des Objekts ist genau Object.prototype.

Mit anderen Worten, das Objekt ist nicht von dem Objekt zu unterscheiden, das mit erstellt wurde {}.

Zusätzlich zu Thevs Antwort:

var o = {};
alert($.toJSON(o)=='{}'); // true

var o = {a:1};
alert($.toJSON(o)=='{}'); // false

es ist jquery + jquery.json

Sugar.JS bietet zu diesem Zweck erweiterte Objekte an. Der Code ist sauber und einfach:

Erstellen Sie ein erweitertes Objekt:

a = Object.extended({})

Überprüfen Sie die Größe:

a.size()