json check - Wie teste ich auf ein leeres JavaScript-Objekt?




if object (25)

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 den Code von JQuery , und Sie erhalten die Antwort:

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

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?


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

Machen Sie ein erweitertes Objekt:

a = Object.extended({})

Überprüfen Sie die Größe:

a.size()

Eine andere Alternative ist die Verwendung von is.js (14kB) im Gegensatz zu jquery (32kB), lodash (50kB) oder underscore (16.4kB). 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 leicht manipulieren müssen, ist jquery möglicherweise eine gute Wahl. Wenn Sie mehr als nur eine lodash benötigen, sind lodash oder underscore gut. Was is.js , so ist die Syntax hier:

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

Dies gilt _.isObject() wie das _.isObject() Underscore und lodash nicht ausschließlich für objects sondern auch für arrays und strings .

Unter der Haube verwendet diese Bibliothek Object.getOwnPropertyNames was Object.getOwnPropertyNames ähnlich Object.keys , Object.getOwnPropertyNames ist jedoch gründlicher, da es Object.getOwnPropertyNames und nicht auflösbare Eigenschaften Object.keys , wie 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 Sie wissen, dass Sie nur Objekte prüfen (keine Arrays oder Strings), sollte die folgende Funktion Ihren Anforderungen entsprechen.

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

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


Ein weiterer einfacher, reiner JS-Weg :)

if (JSON.stringify(pathParams) === '{}')


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

Es verwendet wenn möglich developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… von ECMAScript 5 (ES5), um die beste Leistung (siehe Kompatibilitätstabelle ) und Rückschläge auf den am besten kompatiblen Ansatz für ältere Engines (Browser) zu erzielen.

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!


Vorbehalt! Vorsicht 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

    Beware!! obj is NOT empty!

    obj = {  f:function(){}  }

    JSON.stringify( obj )

    returns

    {}

Neben Thevs Antwort:

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

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

es ist jquery + jquery.json



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.



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.

Boolean(Object.keys(obj)[0])

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

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

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


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

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

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 diese JSFiddle


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

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


  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
    

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.


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 die Unterstützung für ECMAScript 5 verfügbar ist, können Object.keys() stattdessen Object.keys() verwenden:

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

Dies ist meine bevorzugte Lösung:

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

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


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;
    }

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

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 ist das Objekt nicht von einem mit {} erstellten Objekt zu unterscheiden.


John Resig hat eine gute Implementierung gepostet :

// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

Wenn Sie ein globales Objekt nicht erweitern möchten, können Sie stattdessen Folgendes tun:

// Array Remove - By John Resig (MIT Licensed)
Array.remove = function(array, from, to) {
    var rest = array.slice((to || from) + 1 || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.push.apply(array, rest);
};

Der Hauptgrund, warum ich dies poste, ist, Benutzer vor der alternativen Implementierung zu warnen, die in den Kommentaren auf dieser Seite (14. Dezember 2007) vorgeschlagen wird:

Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

Es scheint anfangs gut zu funktionieren, aber durch einen schmerzhaften Prozess habe ich festgestellt, dass es fehlschlägt, wenn versucht wird, das vorletzte Element in einem Array zu entfernen. Wenn Sie beispielsweise ein Array mit 10 Elementen haben und versuchen, das 9. Element folgendermaßen zu entfernen:

myArray.remove(8);

Sie erhalten ein 8-Element-Array. Ich weiß nicht warum, aber ich habe bestätigt, dass Johns ursprüngliche Implementierung dieses Problem nicht hat.





javascript json