AJAX ඉල්ලීමකින් පසුව, සමහර විට මගේ යෙදුම හිස් වස්තුවක් ලබා දෙනු ඇත, වැනි:

var a = {};

එය එසේ දැයි මා පරීක්ෂා කරන්නේ කෙසේද?

ECMA 5+ :

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

කෙසේ වෙතත්, මෙය අනවශ්‍ය අරාවක් (ප්‍රතිලාභ අගය keys) නිර්මාණය කරන බව සලකන්න .

පූර්ව 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

යටි ඉරි :

_.isEmpty({}); // true

හෝක්

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

ExtJS

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

AngularJS (අනුවාදය 1)

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

රාම්ඩා

R.isEmpty({}); // true

මෙය කිරීමට පහසු ක්‍රමයක් නොමැත. ඔබට පැහැදිලිවම ගුණාංග ලූප කිරීමට සිදුවේ:

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

    return true;
}

නම් සම්මතයන් 5 සහාය ලබා ගත හැකි වන අතර, ඔබ භාවිතා කළ හැකිය Object.keys()වෙනුවට:

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

ඔබට එකම ගැටළුවක් ඇති නමුත් jQuery භාවිතා කරන අයට, ඔබට jQuery.isEmptyObject භාවිතා කළ හැකිය .

මෙය මා වඩාත් කැමති විසඳුමයි:

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

ඔබට Underscore.js භාවිතා කළ හැකිය .

_.isEmpty({}); // true

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

http://bencollier.net/2011/04/javascript-is-an-object-empty/ බලන්න

JSON.stringify භාවිතා කරන්නේ කෙසේද? එය සියලුම නවීන බ්‍රව්සර්වල පාහේ ලබා ගත හැකිය.

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

මම ඒ හා සමාන තත්වයකට දිව ගියෙමි. මට JQuery භාවිතා කිරීමට අවශ්‍ය නොවූ අතර පිරිසිදු ජාවාස්ක්‍රිප්ට් භාවිතයෙන් මෙය කිරීමට මට අවශ්‍ය විය.

මම කළේ, පහත දැක්වෙන කොන්දේසිය භාවිතා කිරීම, එය මට වැඩ කළේය.

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

සමාන නොවන නිසා, මෙය භාවිතා කරන්න: JSON.stringify(obj) !== '{}'

මෙම JSFiddle බලන්න

පරණ ප්‍රශ්නය, නමුත් ගැටලුව තිබුනි. ඔබේ එකම අරමුණ වස්තුව හිස් නොවේ දැයි පරීක්ෂා කිරීම නම් JQuery ඇතුළත් කිරීම ඇත්තෙන්ම හොඳ අදහසක් නොවේ. ඒ වෙනුවට, JQuery කේතයට ගැඹුරින් යන්න , එවිට ඔබට පිළිතුර ලැබෙනු ඇත:

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

ඔබ නව බ්‍රව්සරයක සිටී නම් සරල ක්‍රමයක් තිබේ. Object.keys(obj).length == 0

කාර්ය සාධනය

අද 2020.01.17 තෝරාගත් විසඳුම් සඳහා මම මැක් ඕස් හයිසෙයිරා 10.13.6 ක්‍රෝම් v79.0, සෆාරි v13.0.4 සහ ෆයර්ෆොක්ස් v72.0 මත පරීක්ෂණ සිදු කරමි.

නිගමන

• for-in(A, J, L, M) මත පදනම් වූ විසඳුම් වේගවත්ම වේ
• JSON.stringify(B, K) මත පදනම් වූ විසඳුම් මන්දගාමී වේ
• පුදුමයට කරුණක් නම් Object(N) මත පදනම් වූ විසඳුම මන්දගාමී වීමයි

විස්තර

ස්නිපටයේ පහත විසඳුම් 15 ක් ඉදිරිපත් කෙරේ. ඔබේ යන්ත්‍රයේ කාර්ය සාධන පරීක්ෂණය ක්‍රියාත්මක කිරීමට අවශ්‍ය නම් මෙතැන ක්ලික් කරන්න .

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) භාවිතා කිරීම. දිග (ECMA 5+ සඳහා ඉහත යෝජනා කර ඇති පරිදි) හිස් වස්තු සඳහා 10 ගුණයක් මන්දගාමී වේ! පැරණි පාසල (සඳහා ... සඳහා) විකල්පය සමඟ තබා ගන්න.

Node, Chrome, Firefox සහ IE 9 යටතේ පරීක්ෂා කර ඇති විට, බොහෝ භාවිත අවස්ථා සඳහා:

• (for ... in ...) යනු වේගවත්ම විකල්පයයි!
• Object.keys (obj). හිස් වස්තූන් සඳහා දිග 10 ගුණයකින් මන්දගාමී වේ
• JSON.stringify (obj). දිග සෑම විටම මන්දගාමී වේ ( අධිපති නොවේ)
• Object.getOwnPropertyNames (obj) .එය දිග Object.keys (obj) ට වඩා වැඩි කාලයක් ගතවේ .එම පද්ධතිවල දිග බොහෝ දිගු විය හැකිය.

පහළ පේළියේ ක්‍රියාකාරිත්වය නැණවත් ලෙස, භාවිතා කරන්න:

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

හෝ

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

විස්තරාත්මක පරීක්ෂණ ප්‍රති results ල සහ පරීක්ෂණ කේතය බලන්න වස්තුව හිස්ද?

ඔබට වස්තු යතුරු ගණන පරීක්ෂා කළ හැකිය:

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

1. නිකම්ම වැඩ කරන්න. දත්ත නොමැති අවස්ථාවකදී ඔබේ සේවාදායකයාට විශේෂ දේපලක් ජනනය කළ හැකිද?

   උදාහරණයක් වශයෙන්:

   var a = {empty:true};

   එවිට ඔබට එය පහසුවෙන් ඔබේ AJAX ඇමතුම් කේතයෙන් පරීක්ෂා කළ හැකිය.

2. එය පරීක්ෂා කිරීමට තවත් ක්‍රමයක්:

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

සංස්කරණය කරන්න : ඔබ කිසියම් JSON පුස්තකාලයක් (fe JSON.js) භාවිතා කරන්නේ නම් ඔබට JSON.encode () ශ්‍රිතය උත්සාහ කර හිස් අගය නූලට එරෙහිව ප්‍රති result ලය පරීක්ෂා කළ හැකිය.

වස්තුව හිස් දැයි තීරණය කිරීම සඳහා මම සම්පූර්ණ ශ්‍රිතයක් නිර්මාණය කර ඇත්තෙමි.

එය භාවිතා කරයි Object.keysසිට සම්මතයන් 5 හොඳම කාර්ය සාධනය (බලන්න සාක්ෂාත් කර ගැනීම හැකි නම් (ES5) ක්රියාකාරීත්වය ගැළපුම වගුව පැරණි එන්ජින් (බ්රව්සර) සඳහා වඩාත්ම ගැලපෙන ප්රවේශය) සහ fallbacks.

විසඳුමක්

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

මෙන්න මෙම කේතය සඳහා සාරාංශය .

මෙන්න JSFiddle නිරූපණය සහ සරල පරීක්ෂණයක් සමඟ.

එය යමෙකුට උපකාරී වනු ඇතැයි මම බලාපොරොත්තු වෙමි. චියර්ස්!

මම මෙය භාවිතා කරමි.

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

උදා:

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;

මෙතැන් සිට

යාවත්කාලීන කරන්න

හෝ

ඔබට isEmptyObject හි jQuery ක්‍රියාත්මක කිරීම භාවිතා කළ හැකිය

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

පහත උදාහරණයෙන් දැක්වෙන්නේ ජාවාස්ක්‍රිප්ට් වස්තුවක් හිස් දැයි පරීක්ෂා කරන්නේ කෙසේද යන්නයි.

ස්ක්‍රිප්ට් එක 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

Object.entries () හි ES2017 පිරිවිතරයට අනුව , ඕනෑම නවීන බ්‍රව්සරයක් භාවිතයෙන් චෙක්පත සරලයි -

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

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

jQuery isEmptyObject()සඳහා මෙම නඩුවේ විශේෂ කාර්යයක් ඇත:

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

Http://api.jquery.com/jQuery.isEmptyObject/ පිළිබඳ වැඩිදුර කියවන්න

එහි අවම වශයෙන් එක් යතුරක්වත් තිබේදැයි පරීක්ෂා කිරීමට මම යන්නෙමි. එය හිස් නොවන බව මට පැවසීමට එය ප්‍රමාණවත් වේ.

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

කබාය යටතේ සියලුම පුස්තකාලවල ඇති හිස් චෙක්පත් ක්‍රම මඟින් තර්කන පරික්ෂා කිරීමේ වස්තු යතුරු භාවිතා කරයි. එය තේරුම් ගත හැකි අමුතුම ක්‍රමයක් වන අතර, ඔබට ක්‍රමවේදයක් ඉදිරිපත් කළ හැකිය, මෙහි විස්තර කර ඇත .

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

එය ES5 හි පරිණාමය වී ඇති අතර , දැන් සරලව කිවහොත් Object.Keysඔබේ වස්තුව පරාමිතිය ලෙස ගෙන යන ක්‍රමය භාවිතා කරමින් වස්තුවේ යතුරු දිග පරීක්ෂා කළ හැකිය :

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

නැතහොත් ඔබ ලොඩාෂ් භාවිතා කරන්නේ නම් (ඔබ විය යුතුය) එවිට.

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

ඔබට jQuery හෝ වෙනත් පුස්තකාල භාවිතා නොකළ මෙම සරල කේතය භාවිතා කළ හැකිය

var a=({});

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

JSON පන්තිය සහ එහි ක්‍රියාකාරිත්වය ( විග්‍රහ කිරීම සහ දැඩි කිරීම ) ඉතා ප්‍රයෝජනවත් නමුත් IE7 සමඟ යම් යම් ගැටලු ඇති බැවින් ඔබට මෙම සරල කේතය http://www.json.org/js.html සමඟ එය නිවැරදි කළ හැකිය .

වෙනත් සරල මාර්ගය (සරලම මාර්ගය):
ඔබට jQuery හෝ 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

මා සොයාගත් හොඳම ක්‍රමය:

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

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

    return false;
}

මේ සඳහා ක්‍රියා කරයි:

    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

මම ගන්න:

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

සියලුම බ්‍රව්සර් Object.keys()දැනට ක්‍රියාත්මක වන බව මම නොසිතමි .

JQuery සහ වෙබ් බ්‍රව්සරය නොමැති නම්, underscore.js හි isEmpty ශ්‍රිතයක් ද ඇත.

_.isEmpty({}) // returns true

මීට අමතරව, එය ආදාන පරාමිතිය වස්තුවක් ලෙස උපකල්පනය නොකරයි. ලැයිස්තුවක් හෝ නූලක් හෝ නිර්වචනය කර නොමැති නම්, එය නිවැරදි පිළිතුර ද හරවනු ඇත.

නිවැරදි පිළිතුර:

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

මෙය පරීක්ෂා කරන්නේ:

• වස්තුවට තමන්ගේම ගුණාංග නොමැත (ගණන් කිරීමේ හැකියාව නොසලකා).
• වස්තුවට තමන්ගේම දේපල සංකේත නොමැත.
• වස්තුවේ මූලාකෘතිය හරියටම Object.prototypeවේ.

වෙනත් වචන වලින් කිවහොත්, වස්තුව නිර්මාණය කරන ලද එකකින් වෙන් කොට හඳුනාගත නොහැකිය {}.

අවවාදය! 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 ) );

දර්ශන

    පරෙස්සම් වන්න !! obj හිස් නොවේ!

    obj = {f: ශ්‍රිතය () {}}

    JSON.stringify (obj)

    ප්‍රතිලාභ

    {}

තේව්ස් පිළිතුරට අමතරව:

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

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

එය jquery + jquery.json

Sugar.JS මේ සඳහා දීර් extended වස්තු සපයයි. කේතය පිරිසිදු හා සරල ය:

දීර් object වස්තුවක් සාදන්න:

a = Object.extended({})

එහි ප්‍රමාණය පරීක්ෂා කරන්න:

a.size()