Bir AJAX isteğinden sonra, bazen uygulamam aşağıdaki gibi boş bir nesne döndürebilir:

var a = {};

Durumun bu olup olmadığını nasıl kontrol edebilirim?

ECMA 5+ :

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

Bununla birlikte, bunun gereksiz bir dizi (dönüş değeri keys) oluşturduğunu unutmayın.

ECMA Öncesi 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

Alt çizgi :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

Açısal JS (sürüm 1)

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

Ramda

R.isEmpty({}); // true

Bunu yapmanın kolay bir yolu yok. Özellikler üzerinde açıkça döngü yapmanız gerekecek:

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

    return true;
}

Eğer ECMAScript 5 desteği mevcuttur kullanabilirsiniz Object.keys()yerine:

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

Aynı sorunu yaşayan ancak jQuery kullananlarınız için jQuery.isEmptyObject kullanabilirsiniz .

Bu benim tercih ettiğim çözüm:

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

Underscore.js'yi kullanabilirsiniz .

_.isEmpty({}); // true

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

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

JSON.stringify kullanmaya ne dersiniz? Neredeyse tüm modern tarayıcılarda kullanılabilir.

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

Ben de benzer bir durumla karşılaştım. JQuery kullanmak istemiyordu ve saf Javascript kullanarak bunu yapmak istedim.

Ve yaptığım şey, aşağıdaki koşulu kullanmaktı ve benim için çalıştı.

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

Eşit değil için şunu kullanın: JSON.stringify(obj) !== '{}'

Bu JSFiddle'a göz atın

Eski soru, ama sadece sorunu vardı. Tek amacınız nesnenin boş olup olmadığını kontrol etmekse, JQuery'yi eklemek gerçekten iyi bir fikir değildir. Bunun yerine, JQuery'nin kodunun derinliklerinde ve yanıtı alacaksınız:

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

Daha yeni bir tarayıcı kullanıyorsanız basit bir yol vardır. Object.keys(obj).length == 0

Verim

Bugün 2020.01.17 Seçilen çözümler için Chrome v79.0, Safari v13.0.4 ve Firefox v72.0 üzerinde MacOs HighSierra 10.13.6 üzerinde testler yapıyorum.

Sonuçlar

• for-in(A, J, L, M) tabanlı çözümler en hızlısıdır
• JSON.stringify(B, K) tabanlı çözümler yavaştır
• şaşırtıcı bir şekilde Object(N) 'ye dayalı çözüm yavaştır

ayrıntılar

Snippet'te aşağıda 15 çözüm sunulmaktadır. Makinenizde performans testi yapmak istiyorsanız BURAYA tıklayın .

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

Object.keys (obj) .length (yukarıda ECMA 5+ için önerildiği gibi) kullanımı boş nesneler için 10 kat daha yavaştır! eski okul (... için) seçeneği ile devam edin.

Düğüm, Chrome, Firefox ve IE 9 altında test edildiğinde, çoğu kullanım durumunda aşağıdakiler ortaya çıkmaktadır:

• (için ... içinde ...) kullanımı en hızlı seçenektir!
• Object.keys (obj). Boşluğu, boş nesneler için 10 kat daha yavaş
• JSON.stringify (obj). Uzunluk her zaman en yavaş (şaşırtıcı değil)
• Object.getOwnPropertyNames (obj) .length , bazı sistemlerde Object.keys (obj) .length'den daha uzun sürebilir.

Alt satırda performans akıllıca, kullanın:

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

veya

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

Nesne boş mu? Bölümünde ayrıntılı test sonuçlarını ve test kodunu görün.

Nesne anahtarlarının sayısını kontrol edebilirsiniz:

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

1. Sadece bir çözüm. Sunucunuz veri olmaması durumunda özel bir özellik oluşturabilir mi?

   Örneğin:

   var a = {empty:true};

   Ardından AJAX geri arama kodunuzda kolayca kontrol edebilirsiniz.

2. Kontrol etmenin başka bir yolu:

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

DÜZENLEME : Herhangi bir JSON kitaplığı (fe JSON.js) kullanıyorsanız, JSON.encode () işlevini deneyebilir ve sonucu boş değer dizesine karşı test edebilirsiniz.

Nesnenin boş olup olmadığını belirlemek için tam bir işlev oluşturdum.

Bu kullanır Object.keysdan ECMAScript 5 en iyi performansı (bkz elde etmek mümkünse (ES5) işlevselliği uyumluluk tablosu eski motorlara (tarayıcılar) için en uyumlu yaklaşıma) ve yedeklerini.

Çözüm

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

İşte Gist bu kodu.

Ve burada gösteri ve basit bir test ile JSFiddle .

Umarım birine yardım eder. Şerefe!

Bunu kullanıyorum.

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

Örneğin:

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;

buradan

Güncelleme

VEYA

isEmptyObject'in jQuery uygulamasını kullanabilirsiniz

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

Aşağıdaki örnek, bir JavaScript nesnesinin boş olup olmadığını nasıl test edeceğinizi gösterir;

Komut dosyası ES6 üzerinde çalışır.

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

Gereğince ES2017 üzerine şartnamede Object.entries () , çek herhangi bir modern browser-- kullanarak basittir

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

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

jQuery isEmptyObject()bu durum için özel bir işleve sahiptir :

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

Daha fazla bilgi için http://api.jquery.com/jQuery.isEmptyObject/

En az bir anahtar olup olmadığını kontrol etmek için gider. Bana bunun boş olmadığını söylemek yeterli.

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

Kaputun altında, tüm kütüphanelerdeki tüm boş kontrol yöntemleri, nesne anahtarları kontrol mantığını kullanır. Anlaşılabilir hale getirmenin garip bir yolu, burada bir yöntemle koyabilirsiniz, burada açıklanmıştır .

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

ES5'te evrimleşen , şimdi basitçe, nesnenizi Object.Keysparametre olarak alan yöntemi kullanarak nesnenin anahtar uzunluğunu kontrol edebilirsiniz :

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

Ya da Lodash kullanıyorsanız (olmalısınız).

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

jQuery veya diğer kütüphaneleri kullanmayan bu basit kodu kullanabilirsiniz

var a=({});

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

JSON sınıfı ve işlevleri ( ayrıştırma ve stringify ) çok yararlıdır, ancak IE7 ile bu basit kodla düzeltebileceğiniz bazı problemleri vardır http://www.json.org/js.html .

Diğer Basit Yol (en basit Yol): jQuery veya JSON nesnesi
kullanmadan bu yolu kullanabilirsiniz .

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

Bulduğum en iyi yol:

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

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

    return false;
}

Şunun için çalışı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

Benim almam:

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

Sadece, Object.keys()şu anda tüm tarayıcıların uygulandığını düşünmüyorum .

JQuery ve web tarayıcısı mevcut değilse, underscore.js'de bir isEmpty işlevi de vardır.

_.isEmpty({}) // returns true

Ayrıca, giriş parametresinin bir nesne olduğunu varsaymaz. Bir liste veya dize veya tanımsız için doğru yanıtı da döndürür.

Uyarı! JSON'un sınırlamalarına dikkat edin.

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

görüntüler

    Dikkat!! obj boş DEĞİL!

    obj = {f: fonksiyon () {}}

    JSON.stringify (obj)

    İadeler

    {}

Doğru cevap:

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

Bu şunları kontrol eder:

• Nesnenin kendi özellikleri yoktur (numaralandırılabilirlik ne olursa olsun).
• Nesnenin kendi özellik sembolleri yoktur.
• Nesnenin prototipi aynen öyle Object.prototype.

Başka bir deyişle, nesne ile yaratılandan ayırt edilemez {}.

Thevs cevabına ek olarak:

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

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

jquery + jquery.json

Sugar.JS bu amaç için genişletilmiş nesneler sağlar. Kod temiz ve basittir:

Genişletilmiş bir nesne oluşturun:

a = Object.extended({})

Boyutunu kontrol edin:

a.size()