Nie ma na to łatwego sposobu. Będziesz musiał zapętlić właściwości jawnie:

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

    return true;
}

Jeśli Obsługa ECMAScript 5 jest dostępna, możesz użyć Object.keys() zamiast tego:

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

Dla tych z Was, którzy mają ten sam problem, ale używają jQuery, możesz użyć jQuery.isEmptyObject .

To jest moje preferowane rozwiązanie:

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

Możesz użyć podkreślenia.js .

_.isEmpty({}); // true

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

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

Jak o użyciu JSON.stringify? Jest prawie dostępny we wszystkich nowoczesnych przeglądarkach.

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

Stare pytanie, ale miałem problem. Włączenie JQuery nie jest dobrym pomysłem, jeśli jedynym celem jest sprawdzenie, czy obiekt nie jest pusty. Zamiast tego, po prostu głęboko w Kod JQuery , a otrzymasz odpowiedź:

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

Właśnie wpadłem w podobną sytuację. Nie chciałem używać JQuery i chciałem to zrobić za pomocą czystego Javascript.

I to, co zrobiłem, to, użyłem następującego warunku, i to działało dla mnie.

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

For not equal to, use this: JSON.stringify(obj) !== '{}'

Zobacz to JSFiddle

Istnieje prosty sposób, Jeśli korzystasz z nowszej przeglądarki. Object.keys(obj).length == 0

Utworzyłem pełną funkcję, aby określić, czy obiekt jest pusty.

Używa Object.keys od funkcjonalności ECMAScript 5 (ES5), jeśli to możliwe, aby osiągnąć najlepszą wydajność (patrz Tabela kompatybilności ) i wycofuje się do najbardziej zgodnego podejścia dla starszych silników (przeglądarek).

Rozwiązanie

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

Oto Gist dla tego kodu.

A oto JSFiddle z demonstracją i prostym testem.

Mam nadzieję, że pomoże komuś. Zdrowie!

1. To tylko obejście. Czy twój serwer może wygenerować jakąś specjalną właściwość w przypadku braku danych?

   Na przykład:

   var a = {empty:true};
   

   Następnie można łatwo sprawdzić go w kodach zwrotnych AJAX.

2. Inny sposób na sprawdzenie:

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

EDIT : Jeśli używasz dowolnej biblioteki JSON (np.js) następnie możesz spróbować JSON.funkcja encode () i testuje wynik na pustym łańcuchu wartości.

Używanie Obiektu.klucze (obj).długość (jak sugerowano powyżej dla ECMA 5+) jest 10 razy wolniejsza dla pustych obiektów! keep with the old school (for...in) opcja.

Testowane pod Node, Chrom, Firefox i IE 9, staje się oczywiste, że dla większości przypadków użycia:

• (for...in...) jest najszybszą opcją!
• obiekt.klucze (obj).długość jest 10 razy wolniejsza dla pustych obiektów
• JSON.stringify (obj).długość jest zawsze najwolniejsza (nie suprising)
• obiekt.getOwnPropertyNames (obj).długość trwa dłużej niż obiekt.klucze (obj).długość może być znacznie dłuższa w niektórych systemach.

Podsumowując wydajność, użyj:

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

Lub

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

Zobacz szczegółowe wyniki testów i Kod testu na czy obiekt jest pusty?

Możesz sprawdzić liczbę kluczy obiektu:

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

Kolejny prosty, czysty sposób JS:)

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

Używam tego.

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

Eg:

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;

Stąd

Update

Lub

Możesz użyć implementacji jQuery isemptyobject

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

JQuery mają specjalną funkcję isEmptyObject() w tym przypadku:

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

Czytaj więcej na http://api.jquery.com/jQuery.isEmptyObject/

możesz użyć tego prostego kodu, który nie używał jQuery lub innych bibliotek

var a=({});

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

JSON klasa i jej funkcje (parse i stringify ) są bardzo przydatne, ale ma pewne problemy z IE7 , które można naprawić za pomocą tego prostego kodu http://www.json.org/js.html .

inny prosty sposób (najprostszy sposób) :
możesz użyć tego sposobu bez użycia obiektu jQuery lub JSON.

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

Najlepszy sposób jaki znalazłem:

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

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

    return false;
}

Działa dla:

    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

Poniższy przykład pokazuje, jak sprawdzić, czy obiekt JavaScript jest pusty, jeśli przez empty mamy na myśli, że nie ma własnych właściwości.

Skrypt działa na 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

Jeśli jQuery i przeglądarka internetowa nie są dostępne, istnieje również funkcja isEmpty w podkreślniku.js.

_.isEmpty({}) // returns true

Dodatkowo nie przyjmuje parametru wejściowego jako obiektu. Dla listy lub łańcucha znaków lub undefined, będzie również włączyć poprawną odpowiedź.

Moje ujęcie:

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

Po prostu nie sądzę, aby wszystkie przeglądarki implementowały Object.keys() obecnie.

Prosta pętla:

var is_empty = true;
for(var i in obj) {
    is_empty = false;
    break;
}

Oprócz odpowiedzi:

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

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

To jquery + jquery.json

Uwaga! Uważaj na ograniczenia 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 ) );

Wyświetlacze

    Beware!! obj is NOT empty!

    obj = {  f:function(){}  }

    JSON.stringify( obj )

    returns

    {}

Cukier.JS dostarcza do tego celu rozszerzone obiekty. Kod jest czysty i prosty:

Utwórz Rozszerzony obiekt:

a = Object.extended({})

Sprawdź jego rozmiar:

a.size()

Inną alternatywą jest użycie is.js (14kb) w przeciwieństwie do jquery (32kB), lodash (50Kb) lub underscore (16.4 kB). jest.js okazał się najszybszą biblioteką spośród wyżej wymienionych bibliotek, która mogła zostać użyta do określenia, czy obiekt jest pusty.

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

Oczywiście wszystkie te biblioteki nie są dokładnie takie same, więc jeśli chcesz łatwo manipulować DOM, to jquery może być dobrym wyborem lub jeśli potrzebujesz więcej niż tylko sprawdzanie typu, to lodash lub underscore może być dobry. Co do jest.js , Oto składnia:

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

Podobnie jak podkreślenia i lodash _.isObject(), Nie dotyczy to wyłącznie objects, ale dotyczy również arrays i strings.

Pod maską ta biblioteka używa Object.getOwnPropertyNames, która jest podobna do Object.keys, Ale Object.getOwnPropertyNames jest bardziej dokładna, ponieważ zwróci liczbę i liczbę właściwości opisane tutaj .

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

Jeśli nie chcesz wnosić biblioteki (co jest zrozumiałe) i wiesz, że sprawdzasz tylko obiekty (nie tablice czy ciągi znaków), poniższa funkcja powinna odpowiadać Twoim potrzebom.

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

To jest tylko trochę szybsze niż jest.js tylko dlatego, że nie sprawdzasz, czy jest to obiekt.

Prawidłowa odpowiedź brzmi:

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

To sprawdza, że:

• obiekt nie ma własnych właściwości(bez względu na możliwość wyliczenia).
• obiekt nie posiada własnych symboli właściwości.
• prototyp obiektu jest dokładnie Object.prototype.

Innymi słowy, obiekt jest nie do odróżnienia od obiektu utworzonego za pomocą {}.

Chciałbym sprawdzić, czy ma przynajmniej jeden klucz. To by mi wystarczyło, żeby powiedzieć, że nie jest pusta.

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