it-swarm.com.de

Wie teste ich auf ein leeres JavaScript-Objekt?

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

var a = {};

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

2167
falmp

ECMA 7+ :

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

ECMA 5+ :

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

Vor 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

Unterstrich :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (Version 1)

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

Ramda

R.isEmpty({}); // true
3686
Adam Zerner

Es gibt keinen einfachen Weg, 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 stattdessen Object.keys() verwenden:

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

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

547
Erik Töyrä

Dies ist meine bevorzugte Lösung:

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

Sie können Underscore.js verwenden.

_.isEmpty({}); // true
191
Baggz
if(Object.getOwnPropertyNames(obj).length === 0){
  //is empty
}

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

107
es cologne

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

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

Alte Frage, hatte aber gerade das Problem. Das Einschließen von JQuery ist nicht wirklich eine gute Idee, wenn Sie nur prüfen möchten, ob das Objekt nicht leer ist. Stattdessen nur tief in JQuery's Code , und Sie erhalten die Antwort:

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

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

Und was ich tat, war folgende Bedingung, 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 das: JSON.stringify(obj) !== '{}'

Schauen Sie sich das an JSFiddle

47
Anish Nair

Es gibt einen einfachen Weg, wenn Sie sich in einem neueren Browser befinden .Object.keys(obj).length == 0

28
download

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

Es verwendet Object.keys from ECMAScript 5 (ES5) -Funktionalität, falls möglich, um die beste Leistung (siehe Kompatibilitätstabelle ) und Rückschläge auf den kompatibelsten Ansatz für ältere Engines (Browser) zu erreichen.

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 der Gist für diesen Code.

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

Ich hoffe es hilft jemandem. Prost!

21
Slava Fomin II

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

if (Object.keys(a).length > 0) {
    // not empty
}
20
Ashutosh Ranjan
  1. Nur ein Workaround. Kann Ihr Server eine spezielle Eigenschaft generieren, wenn keine Daten vorhanden sind?

    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
    

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

19
Thevs

Die Verwendung von Object.keys (obj) .length (wie oben für ECMA 5+ empfohlen) ist für leere Objekte zehnmal langsamer! Bleib bei der alten Schule (für ... in).

Bei Node, Chrom, Firefox und IE 9 getestet, 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 manchen Systemen viel länger sein.

Unterm Strich Leistung weise verwenden:

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?

17
davidhadas

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

Update

OR

sie können die jQuery-Implementierung von isEmptyObject verwenden

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

Das folgende Beispiel zeigt, wie Sie testen können, ob ein JavaScript-Objekt leer ist. Wenn also leer bedeutet, haben Sie keine eigenen Eigenschaften.

Das Skript funktioniert auf 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

11
GibboK
function isEmpty(obj) {
  for(var i in obj) { return false; }
  return true;
}
10
ikettu

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

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

Weitere Informationen finden Sie auf http://api.jquery.com/jQuery.isEmptyObject/

10

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
9
DiegoAraujo


Sie können diesen einfachen Code verwenden, der jQuery oder andere Bibliotheken nicht verwendet

var a=({});

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

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 .

Andere einfache Art (einfachste Art):
Sie können diesen Weg verwenden, ohne das jQuery - oder JSON - Objekt zu 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
9
iman

Meine nehmen:

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 derzeit alle Browser Object.keys() implementieren.

8
NiKo

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])
8
Tudor Morar

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

_.isEmpty({}) // returns true

Darüber hinaus nimmt es nicht an, dass der Eingabeparameter ein Objekt ist. Bei einer Liste oder Zeichenfolge oder undefiniert wird auch die richtige Antwort angezeigt.

8
jichi

Gemäß der ES2017 -Spezifikation in Object.entries () lautet die Prüfung einfach mit jedem modernen Browser -

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

Die richtige Antwort ist:

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

Dies prü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 einem mit {} erstellten Objekt zu unterscheiden.

5
Jesse

Vorbehalt! Hüten Sie sich vor den 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 ) );

zeigt an

 In acht nehmen!! obj ist NICHT leer! 

 obj = {f: function () {}} 

 JSON.stringify (obj) 

 kehrt zurück

 {} 
5
Ekim

Neben der Antwort von Thevs:

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

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

es ist jquery + jquery.json

4
starikovs

Sugar.JS stellt für diesen Zweck erweiterte Objekte bereit. Der Code ist sauber und einfach:

Machen Sie ein erweitertes Objekt:

a = Object.extended({})

Überprüfen Sie die Größe:

a.size()
4
mikemaccana

Eine andere Alternative ist, is.js (14kB) im Gegensatz zu jquery (32kB), lodash (50kB) oder Unterstrich (16.4kB) zu verwenden. is.js erwies sich als die schnellste Bibliothek unter den zuvor genannten Bibliotheken, mit der festgestellt werden kann, ob ein Objekt leer ist.

http://jsperf.com/check-empty-object-using-libraries

Offensichtlich sind alle diese Bibliotheken nicht genau gleich. Wenn Sie also das DOM auf einfache Weise bearbeiten müssen, ist jquery möglicherweise eine gute Wahl. Wenn Sie mehr als nur eine Textprüfung benötigen, dann lodash oder Unterstrich könnte gut sein. Wie für is.js ist hier die Syntax:

var a = {};
is.empty(a); // true
is.empty({"hello": "world"}) // false

Wie bei Unterstrichen und Lodashs _.isObject() gilt dies nicht ausschließlich für objects, sondern auch für arrays und strings.

Unter der Haube verwendet diese Bibliothek Object.getOwnPropertyNames, die Object.keys ähnlich ist, aber Object.getOwnPropertyNames ist gründlicher, da sie auflösbare und nicht aufzählbare Eigenschaften zurückgibt, wie in here beschrieben.

is.empty = function(value) {
    if(is.object(value)){
        var num = Object.getOwnPropertyNames(value).length;
        if(num === 0 || (num === 1 && is.array(value)) || (num === 2 && is.arguments(value))){
            return true;
        }
        return false;
    } else {
        return value === '';
    }
};

Wenn Sie keine Bibliothek mitbringen möchten (was verständlich ist) und wissen, dass Sie nur Objekte prüfen (keine Arrays oder Strings), dann sollte die folgende Funktion Ihren Anforderungen entsprechen.

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

Dies ist nur ein wenig schneller als is.js, nur weil Sie nicht prüfen, ob es ein Objekt ist.

3
cwadding

Alle leeren Prüfmethoden in allen Bibliotheken verwenden Objektprüfungslogik. Es ist eine seltsame Weise, es verständlich zu machen, die Sie in eine Methode einfügen können, Beschrieben hier .

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

Was sich in ES5 entwickelt hat, können Sie nun einfach die Schlüssellänge des Objekts überprüfen, indem Sie die Object.Keys-Methode verwenden, die Ihr Objekt als Parameter nimmt:

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

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

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

Ich kann nicht glauben, nach zwei Jahren der Programmierung, dass es nie geklickt hat, dass leere Objekte und Arrays nicht falsch sind.

dies gibt true zurück, wenn die Eingabe standardmäßig falsch ist oder wenn es sich um ein leeres Objekt oder ein leeres Array handelt. Die Umkehrung ist die trueish-Funktion

http://codepen.io/synthet1c/pen/pjmoWL

function falsish( obj ){
    if( (typeof obj === 'number' && obj > 0) || obj === true ){
        return false;
    }
    return !!obj
        ? !Object.keys( obj ).length
        : true;
}

function trueish( obj ){
    return !falsish( obj );
}

falsish({})           //=> true
falsish({foo:'bar'})  //=> false
falsish([])           //=> true
falsish(['foo'])      //=> false
falsish(false)        //=> true
falsish(true)         //=> false
// the rest are on codepen
2
synthet1c

dieser einzeilige Code hilft 

var a = {}; //if empty returns false
(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(a).length != 0 : (function(){for(var key in a) break; return (key != null) && (key != undefined);})()) //Returns False

var a = {b:2} //if not empty returns true
(Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(a).length != 0 : (function(){for(var key in a) break; return (key != null) && (key != undefined);})()) //Returns true

Object.getOwnPropertyNames ist in ECMA-5 implementiert. Die obige Zeile funktioniert in älteren Browsern mit einer Fallback-Funktion.

JSFiddler

2
Nirus
    isEmpty = function(obj) {
      if (obj == null) return true;
      if (obj.constructor.name == "Array" || obj.constructor.name == "String") return obj.length === 0;
      for (var key in obj) if (isEmpty(obj[key])) return true;
      return false;
    }

Dadurch wird die Leere von String, Array oder Object (Maps) überprüft.

Verwendungszweck : 

var a = {"a":"xxx","b":[1],"c":{"c_a":""}}
isEmpty(a); // true, because a.c.c_a is empty.
isEmpty("I am a String"); //false
2
Rahul Malhotra
export function isObjectEmpty(obj) {
  return (
    Object.keys(obj).length === 0 &&
    Object.getOwnPropertySymbols(obj).length === 0 &&
    obj.constructor === Object
  );
}

Dies beinhaltet das Prüfen auf Objekte, die Symboleigenschaften enthalten.

Object.keys ruft keine Symboleigenschaften ab.

1
Jplus2

In der Zwischenzeit können wir eine Funktion haben, die nach allen 'Leergut' sucht, wie null, undefined, '', '', {}, [] .

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        }
        return false;
    }else if(typeof(data) === 'string'){
        if(!data.trim()){
            return true;
        }
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
    }else{
        return false;
    }
}

Anwendungsfälle und Ergebnisse.

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false
1
Imran

Versuch Zerstörung

const a = {};
const { b } = a;
const emptryOrNot = (b) ? 'not Empty' : 'empty';
console.log(emptryOrNot)
1
Igor Kokotko

Es ist seltsam, dass ich hier keinen Vergleich nach Werten finde (vielleicht unter so vielen Lösungen vermisst). Ich möchte den Fall behandeln, in dem ein Objekt als leer betrachtet wird, wenn alle seine Werte undefiniert sind: 

const isObjectEmpty = ( obj ) => Object.values( obj  ).every( val => typeof val === "undefined" );

isObjectEmpty({ foo: undefined, bar: undefined }): // true
isObjectEmpty({ foo: false, bar: null }): // false

Daher können wir das Optionsobjekt nur erweitern, wenn Unteroptionen bereitgestellt werden

function onSubmit({ fullPage, width, height }) {
const baseOptions = { fullPage },
      clip = { width, height },
      options = isObjectEmpty( clip ) ? baseOptions : { ...baseOptions, clip };
//...
}
0
Dmitry Sheiko

Reines Vanilla Javascript und volle Abwärtskompatibilität

function isObjectDefined (Obj) {
  if (Obj === null || typeof Obj !== 'object' ||
    Object.prototype.toString.call(Obj) === '[object Array]') {
    return false
  } else {
    for (var prop in Obj) {
      if (Obj.hasOwnProperty(prop)) {
        return true
      }
    }
    return JSON.stringify(Obj) !== JSON.stringify({})
  }
}

console.log(isObjectDefined()) // false
console.log(isObjectDefined('')) // false
console.log(isObjectDefined(1)) // false
console.log(isObjectDefined('string')) // false
console.log(isObjectDefined(NaN)) // false
console.log(isObjectDefined(null)) // false
console.log(isObjectDefined({})) // false
console.log(isObjectDefined([])) // false
console.log(isObjectDefined({a: ''})) // true

UmONLY{} wirklich zu akzeptieren, ist der beste Weg, dies in Javascript mit Lodash zu tun:

_.isEmpty(value) && _.isPlainObject(value)
0
Anthony D'Amato

Sie können Ihren eigenen Objektprototyp definieren, direkt vor der Verwendung oder am Anfang Ihres Codes.

Die Definition sollte so aussehen:

Object.prototype.hasOwnProperties = function()
{ 
  for (var k in this)
  { 
    if ( this.hasOwnProperty(k) )
    { 
      return true;
    } 
  }
  return false;
}

Hier ist ein Anwendungsbeispiel:

var a = {};

while ( a.status !== "finished" )
{  
  if ( status === "processing" )
  {
    a.status = "finished";  
  }
  
  if ( status === "starting" )
  {
    a.status = "processing";  
  }
  
  if ( !a.hasOwnProperties() )
  {
    a.status = "starting";
  }
}

Genießen! :-)

0
Slavik Meltser

Ich gab eine leere JSON-Antwort für einen AJAX - Aufruf zurück, und in IE8 wurde jQuery.isEmptyObject () nicht ordnungsgemäß überprüft. Ich fügte einen zusätzlichen Check hinzu, der es scheinbar richtig fängt.

.done(function(data)
{  
    // Parse json response object
    var response = jQuery.parseJSON(data);

    // In IE 8 isEmptyObject doesn't catch the empty response, so adding additional undefined check
    if(jQuery.isEmptyObject(response) || response.length === 0)
    {
        //empty
    }
    else
    {
        //not empty
    }
});
0
CatTest

Ab jQuery 1.4 überprüft die isEmptyObject()-Methode sowohl Eigenschaften des Objekts selbst als auch Eigenschaften, die von Prototypen geerbt wurden (dh, dass keine hasOwnProperty verwendet wird). Das Argument sollte immer ein einfaches JavaScript-Objekt sein, da andere Objekttypen (DOM-Elemente, primitive Zeichenfolgen/Zahlen, Host-Objekte) in Browsern möglicherweise keine konsistenten Ergebnisse liefern. Verwenden Sie $.isPlainObject(), um festzustellen, ob ein Objekt ein einfaches JavaScript-Objekt ist.

jQuery.isPlainObject({}) // true

jQuery.isPlainObject( "test" ) // false

Jquery api

0
chandu

Dies ist, was ich erfunden habe, um festzustellen, ob das Objekt andere Werte als Null enthält.

function isEmpty(obj: Object): Boolean {
    for (const prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            if (obj[prop] instanceof Object) {
                const rtn = this.isEmpty(obj[prop]);
                if (rtn === false) {
                  return false;
                }
            } else if (obj[prop] || obj[prop] === false) {
                return false;
            }
        }
    }
    return true;
}
0
Jonathan