Setelah permintaan AJAX, terkadang aplikasi saya dapat mengembalikan objek kosong, seperti:

var a = {};

Bagaimana saya dapat memeriksa apakah itu masalahnya?

ECMA 5+ :

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

Perhatikan, bagaimanapun, bahwa ini menciptakan array yang tidak perlu (nilai balik dari keys).

Pra-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

Garis bawah :

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (versi 1)

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

Ramda

R.isEmpty({}); // true

Tidak ada cara mudah untuk melakukan ini. Anda harus mengulang properti secara eksplisit:

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

    return true;
}

Jika dukungan ECMAScript 5 tersedia, Anda dapat menggunakannya Object.keys():

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

Bagi Anda yang memiliki masalah yang sama tetapi menggunakan jQuery, Anda dapat menggunakan jQuery.isEmptyObject .

Ini adalah solusi pilihan saya:

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

Anda dapat menggunakan Underscore.js .

_.isEmpty({}); // true

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

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

Bagaimana dengan menggunakan JSON.stringify? Ini hampir tersedia di semua browser modern.

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

Saya hanya mengalami situasi yang sama. Saya tidak ingin menggunakan JQuery, dan ingin melakukan ini menggunakan Javascript murni.

Dan apa yang saya lakukan adalah, menggunakan kondisi berikut, dan itu berhasil untuk saya.

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

Untuk tidak sama dengan, gunakan ini: JSON.stringify(obj) !== '{}'

Lihatlah JSFiddle ini

Pertanyaan lama, tetapi baru saja memiliki masalah. Termasuk JQuery sebenarnya bukan ide yang bagus jika tujuan Anda satu-satunya adalah memeriksa apakah objek tidak kosong. Sebaliknya, cukup jauh ke dalam kode JQuery , dan Anda akan mendapatkan jawabannya:

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

Ada cara sederhana jika Anda menggunakan browser yang lebih baru. Object.keys(obj).length == 0

Performa

Hari ini 2020.01.17 Saya melakukan tes pada MacOs HighSierra 10.13.6 di Chrome v79.0, Safari v13.0.4 dan Firefox v72.0, untuk solusi yang dipilih.

Kesimpulan

• solusi berdasarkan for-in(A, J, L, M) adalah yang tercepat
• solusi berdasarkan JSON.stringify(B, K) lambat
• mengherankan juga solusi berdasarkan Object(N) lambat

Detail

Dalam cuplikan di bawah ini disajikan 15 solusi. Jika Anda ingin menjalankan tes kinerja pada mesin Anda, klik DI SINI .

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

Menggunakan Object.keys (obj) .length (seperti yang disarankan di atas untuk ECMA 5+) 10 kali lebih lambat untuk objek kosong! tetap dengan opsi sekolah lama (untuk ... dalam).

Diuji di bawah Node, Chrome, Firefox dan IE 9, menjadi jelas bahwa untuk sebagian besar kasus penggunaan:

• (untuk ... dalam ...) adalah opsi tercepat untuk digunakan!
• Object.keys (obj). Panjangnya 10 kali lebih lambat untuk objek kosong
• JSON.stringify (obj). Panjang selalu yang paling lambat (tidak mengejutkan)
• Object.getOwnPropertyNames (obj) .length membutuhkan waktu lebih lama dari Object.keys (obj) .length bisa lebih lama pada beberapa sistem.

Kinerja bottom line, gunakan:

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

atau

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

Lihat hasil pengujian terperinci dan kode pengujian di Apakah objek kosong?

Anda dapat memeriksa jumlah kunci Objek:

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

1. Hanya solusinya. Bisakah server Anda menghasilkan beberapa properti khusus jika tidak ada data?

   Sebagai contoh:

   var a = {empty:true};

   Maka Anda dapat dengan mudah memeriksanya dalam kode panggilan balik AJAX Anda.

2. Cara lain untuk memeriksanya:

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

EDIT : Jika Anda menggunakan pustaka JSON (fe JSON.js), maka Anda dapat mencoba fungsi JSON.encode () dan menguji hasilnya terhadap string nilai kosong.

Saya telah membuat fungsi lengkap untuk menentukan apakah objek kosong.

Ini menggunakan Object.keysdari fungsionalitas ECMAScript 5 (ES5) jika memungkinkan untuk mencapai kinerja terbaik (lihat tabel kompatibilitas ) dan mundur ke pendekatan yang paling kompatibel untuk mesin yang lebih lama (browser).

Larutan

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

Inilah Intisari untuk kode ini.

Dan inilah JSFiddle dengan demonstrasi dan tes sederhana.

Saya harap ini akan membantu seseorang. Bersulang!

Saya menggunakan ini.

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

Misalnya:

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;

dari sini

Memperbarui

ATAU

Anda dapat menggunakan implementasi jQuery dari isEmptyObject

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

Contoh berikut menunjukkan cara menguji apakah objek JavaScript kosong, jika dengan kosong kami berarti tidak memiliki properti sendiri.

Script berfungsi pada 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

Sesuai spesifikasi ES2017 pada Object.entries () , pemeriksaannya sederhana menggunakan peramban modern mana pun -

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

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

jQuery memiliki fungsi khusus isEmptyObject()untuk kasus ini:

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

Baca lebih lanjut di http://api.jquery.com/jQuery.isEmptyObject/

Saya akan memeriksa apakah memiliki setidaknya satu kunci. Itu sudah cukup untuk memberi tahu saya bahwa itu tidak kosong.

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

Di bawah tenda semua metode pemeriksaan kosong di semua perpustakaan menggunakan kunci objek memeriksa logika. Ini cara yang aneh untuk membuatnya dimengerti, yang dapat Anda masukkan ke dalam metode, Dijelaskan di sini .

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

Yang telah berevolusi dalam ES5 , sekarang secara sederhana Anda dapat memeriksa panjang kunci objek, menggunakan Object.Keysmetode yang mengambil objek Anda sebagai parameternya:

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

Atau jika Anda menggunakan Lodash (Anda harus) maka.

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

Anda dapat menggunakan kode sederhana ini yang tidak menggunakan jQuery atau perpustakaan lain

var a=({});

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

Kelas JSON dan fungsinya ( parse dan stringify ) sangat berguna tetapi memiliki beberapa masalah dengan IE7 yang dapat Anda perbaiki dengan kode sederhana ini http://www.json.org/js.html .

Other Simple Way (Cara paling sederhana):
Anda bisa menggunakan cara ini tanpa menggunakan objek jQuery atau 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

Cara terbaik yang saya temukan:

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

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

    return false;
}

Bekerja untuk:

    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

Saya ambil:

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

Hanya, saya tidak berpikir semua browser menerapkan Object.keys()saat ini.

Jika jQuery dan browser web tidak tersedia, ada juga fungsi isEmpty di underscore.js.

_.isEmpty({}) // returns true

Selain itu, ia tidak menganggap parameter input sebagai objek. Untuk daftar atau string atau tidak terdefinisi, itu juga akan mengubah jawaban yang benar.

Peringatan! Waspadai batasan 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 ) );

menampilkan

    Waspadalah !! obj TIDAK kosong!

    obj = {f: function () {}}

    JSON.stringify (obj)

    kembali

    {}

Jawaban yang benar adalah:

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

Ini memeriksa bahwa:

• Objek tidak memiliki properti sendiri (terlepas dari enumerability).
• Objek tidak memiliki simbol properti sendiri.
• Prototipe objeknya persis Object.prototype.

Dengan kata lain, objek tidak dapat dibedakan dari objek yang dibuat {}.

Selain jawaban Thevs:

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

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

itu jquery + jquery.json

Sugar.JS menyediakan objek yang diperluas untuk tujuan ini. Kode ini bersih dan sederhana:

Buat objek yang diperluas:

a = Object.extended({})

Periksa ukurannya:

a.size()