ජාවාස්ක්‍රිප්ට් හි ඇති වස්තුවක යතුරු / ගුණාංග ගණන කාර්යක්ෂමව ගණනය කරන්නේ කෙසේද?

වස්තුවක යතුරු / ගුණාංග ගණන ගණනය කිරීමට වේගවත්ම ක්‍රමය කුමක්ද? වස්තුවට වඩා පුනරාවර්තනයකින් තොරව මෙය කළ හැකිද? එනම් නොකර

var count = 0;
for (k in myobj) if (myobj.hasOwnProperty(k)) count++;

(ෆයර්ෆොක්ස් විසින් මැජික් __count__දේපලක් ලබා දී ඇත, නමුත් මෙය 4 වන අනුවාදය වටා කොතැනක හෝ ඉවත් කරන ලදි.)

Node , Chrome, IE 9+, Firefox 4+, හෝ Safari 5+ වැනි ඕනෑම ES5 අනුකූල පරිසරයක මෙය සිදු කිරීම සඳහා :

Object.keys(obj).length

• බ්‍රව්සර් අනුකූලතාව
• Object.keys ප්‍රලේඛනය (ඔබට ES5 නොවන බ්‍රව්සර් වලට එකතු කළ හැකි ක්‍රමයක් ඇතුළත් වේ)

ඔබට මෙම කේතය භාවිතා කළ හැකිය:

if (!Object.keys) {
    Object.keys = function (obj) {
        var keys = [],
            k;
        for (k in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, k)) {
                keys.push(k);
            }
        }
        return keys;
    };
}

එවිට ඔබට මෙය පැරණි බ්‍රව්සර්වලද භාවිතා කළ හැකිය:

var len = Object.keys(obj).length;

ඔබ Underscore.js භාවිතා කරන්නේ නම් ඔබට _.size භාවිතා කළ හැකිය (ස්තූතියි ou ඩව්):
_.size(obj)

විකල්පයක් ලෙස ඔබට සමහර අයට වඩා පැහැදිලි විය හැකි _.keys භාවිතා කළ හැකිය:
_.keys(obj).length

මූලික දේ රාශියක් කිරීම සඳහා එහි තද පුස්තකාලයක් වන අන්ඩර්ස්කෝර් මම තරයේ නිර්දේශ කරමි. හැකි සෑම විටම ඒවා ECMA5 සමඟ ගැලපෙන අතර ස්වදේශීය ක්‍රියාත්මක කිරීමට කල් දමයි.

නැතිනම් මම අවීගේ පිළිතුරට සහය දෙමි. ECMA5 නොවන බ්‍රව්සර් වලට ඔබට එකතු කළ හැකි යතුරු () ක්‍රමය ඇතුළත් වන MDC ලේඛනයට සබැඳියක් එක් කිරීමට මම එය සංස්කරණය කළෙමි.

සම්මත වස්තු ක්‍රියාත්මක කිරීම ( ES5.1 වස්තු අභ්‍යන්තර ගුණාංග සහ ක්‍රම ) සඳහා Objectඑහි යතුරු / ගුණාංග ගණන සොයා ගැනීමට අවශ්‍ය නොවේ , එබැවින් Objectඑහි යතුරු පැහැදිලිව හෝ ව්‍යංගයෙන් නොකියවා එහි ප්‍රමාණය තීරණය කිරීමට සම්මත ක්‍රමයක් නොතිබිය යුතුය .

එබැවින් වඩාත් බහුලව භාවිතා වන විකල්ප මෙන්න:

1. ECMAScript හි Object.keys ()

Object.keys(obj).length;තාවකාලික අරාව ගණනය කිරීම සඳහා යතුරු හරහා අභ්‍යන්තරව පුනරාවර්තනය කිරීමෙන් ක්‍රියා කරන අතර එහි දිග නැවත ලබා දේ.

• වාසි - කියවිය හැකි සහ පිරිසිදු සින්ටැක්ස්. ස්වදේශීය සහාය නොමැති නම් ෂිම් එකක් හැර පුස්තකාලයක් හෝ අභිරුචි කේතයක් අවශ්‍ය නොවේ
• අවාසි - අරාව නිර්මාණය කිරීම නිසා මතකය ඉහළින්.

2. පුස්තකාල පදනම් කරගත් විසඳුම්

මෙම මාතෘකාවේ වෙනත් තැනක ඇති පුස්තකාල පදනම් කරගත් බොහෝ උදාහරණ ඔවුන්ගේ පුස්තකාලයේ සන්දර්භය තුළ ප්‍රයෝජනවත් මෝඩයන් වේ. කෙසේ වෙතත්, කාර්ය සාධන දෘෂ්ටි කෝණයකින්, පරිපූර්ණ පුස්තකාල Object.keysරහිත කේතයකට සාපේක්ෂව ලබා ගත හැකි කිසිවක් නැත, මන්ද එම පුස්තකාල ක්‍රම සියල්ලම ඇත්ත වශයෙන්ම ලූප් සඳහා හෝ ඊඑස් 5 (ස්වදේශීය හෝ දිලිසෙන) සමඟ සංයුක්ත වේ.

3. ලූපයක් ප්‍රශස්ත කිරීම

මෙම මන්දගාමී වේ කොටසක් සඳහා-පුඩුවක් එවැනි පොදුවේ යනු .hasOwnProperty()ඒ function ඇමතුමක් සෝපානත්, ඇමතුම. එබැවින් මට JSON වස්තුවක ඇතුළත් කිරීම් ගණන අවශ්‍ය වූ විට, .hasOwnProperty()කිසිදු කේතයක් හෝ දීර් Object.prototype. නොවන බව මා දන්නේ නම් මම ඇමතුම මඟ හරින්නෙමි .

එසේ නොමැතිනම්, kදේශීය ( var k) සෑදීමෙන් සහ ++countපෝස්ට්ෆික්ස් වෙනුවට උපසර්ග වර්ධක ක්‍රියාකරු ( ) භාවිතා කිරීමෙන් ඔබේ කේතය තරමක් ප්‍රශස්ත කළ හැකිය .

var count = 0;
for (var k in myobj) if (myobj.hasOwnProperty(k)) ++count;

තවත් අදහසක් රඳා පවතින්නේ hasOwnPropertyක්‍රමවේදය හැඹිලිගත කිරීම මත ය :

var hasOwn = Object.prototype.hasOwnProperty;
var count = 0;
for (var k in myobj) if (hasOwn.call(myobj, k)) ++count;

දී ඇති පරිසරයක මෙය වේගවත් ද නැද්ද යන්න මිණුම් සලකුණු කිරීමේ ප්‍රශ්නයකි. කෙසේ වෙතත් ඉතා සීමිත කාර්ය සාධන ලාභයක් අපේක්ෂා කළ හැකිය.

ඔබ සැබවින්ම කාර්ය සාධන ගැටලුවකට මුහුණ දෙන්නේ නම්, නිසි ලෙස නම් කරන ලද (ප්‍රමාණය?) දේපලක් වැඩි කරන / අඩු කරන ශ්‍රිතයක් සමඟ වස්තුවට / වෙතින් දේපල එකතු කරන / ඉවත් කරන ඇමතුම් එතීමට මම යෝජනා කරමි.

ඔබට අවශ්‍ය වන්නේ ආරම්භක දේපල සංඛ්‍යාව එක් වරක් පමණක් ගණනය කර එතැනින් ඉදිරියට යාමයි. සැබෑ කාර්ය සාධන ගැටලුවක් නොමැති නම්, කරදර නොවන්න. එම කේතය ටිකක් ශ්‍රිතයක් getNumberOfProperties(object)තුළට ඔතා එය සමඟ කරන්න.

අවී ෆ්ලැක්ස් ප්‍රකාශ කළ පරිදි https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

ඔබේ වස්තුවෙහි ඇති සියළුම ගණනය කළ හැකි ගුණාංග සඳහා උපක්‍රමය කරනු ඇති අතර ඒ වෙනුවට ඔබට භාවිතා කළ හැකි ගණන් කළ නොහැකි ගුණාංග ද ඇතුළත් වේ Object.getOwnPropertyNames. මෙන්න වෙනස:

var myObject = new Object();

Object.defineProperty(myObject, "nonEnumerableProp", {
  enumerable: false
});
Object.defineProperty(myObject, "enumerableProp", {
  enumerable: true
});

console.log(Object.getOwnPropertyNames(myObject).length); //outputs 2
console.log(Object.keys(myObject).length); //outputs 1

console.log(myObject.hasOwnProperty("nonEnumerableProp")); //outputs true
console.log(myObject.hasOwnProperty("enumerableProp")); //outputs true

console.log("nonEnumerableProp" in myObject); //outputs true
console.log("enumerableProp" in myObject); //outputs true

ප්රකාශ කළ පරිදි, මෙහි මෙම එකම බ්රවුසරයට සහාය ලෙස ඇතObject.keys

කෙසේ වෙතත්, බොහෝ අවස්ථාවන්හීදී, මෙම වර්ගයේ මෙහෙයුම් සඳහා ගණන් කළ නොහැකි දෑ ඇතුළත් කිරීමට ඔබට අවශ්‍ය නොවනු ඇත, නමුත් වෙනස දැන ගැනීම සැමවිටම හොඳයි;)

මෙය සිදු කළ හැකි ක්‍රමයක් ගැන මම නොදනිමි, කෙසේ වෙතත් පුනරාවර්තනයන් අවම මට්ටමක තබා ගැනීමට, ඔබට __count__එහි පැවැත්ම පරීක්ෂා කර බැලීමට උත්සාහ කළ හැකි අතර එය නොපවතී නම් (එනම් ෆයර්ෆොක්ස් නොවේ) එවිට ඔබට වස්තුව හරහා නැවත අර්ථ දැක්විය හැකිය එය පසුව භාවිතා කිරීම සඳහා උදා:

if (myobj.__count__ === undefined) {
  myobj.__count__ = ...
}

මේ ආකාරයට ඕනෑම බ්‍රව්සරයක් සහය දක්වන අය __count__එය භාවිතා කරනු ඇති අතර, නැවත සිදුකිරීම් සිදු කරනු ලබන්නේ එසේ නොකරන අයට පමණි. ගණනය වෙනස් වී ඔබට මෙය කළ නොහැකි නම්, ඔබට එය සැමවිටම ශ්‍රිතයක් බවට පත් කළ හැකිය:

if (myobj.__count__ === undefined) {
  myobj.__count__ = function() { return ... }
  myobj.__count__.toString = function() { return this(); }
}

ඔබ myobj සඳහන් කරන ඕනෑම වේලාවක මේ ආකාරයෙන්. __count__ශ්‍රිතය ගිනිගෙන නැවත ගණනය කරනු ඇත.

Avi Flax පිළිතුර Obte.keys (obj) මත නැවත සැකසීම .එහි කාර්යයන් බැඳී නැති වස්තුවක් සඳහා දිග නිවැරදි වේ

උදාහරණයක්:

obj = {"lol": "what", owo: "pfft"};
Object.keys(obj).length; // should be 2

එදිරිව

arr = [];
obj = {"lol": "what", owo: "pfft"};
obj.omg = function(){
    _.each(obj, function(a){
        arr.push(a);
    });
};
Object.keys(obj).length; // should be 3 because it looks like this 
/* obj === {"lol": "what", owo: "pfft", omg: function(){_.each(obj, function(a){arr.push(a);});}} */

මෙය වළක්වා ගැනීමට පියවර:

1. ඔබට යතුරු ගණන ගණනය කිරීමට අවශ්‍ය වස්තුවක කාර්යයන් නොතබන්න

2. ශ්‍රිත සඳහා වෙනම වස්තුවක් භාවිතා කරන්න හෝ නව වස්තුවක් සාදන්න (ඔබට භාවිතා කරන ගොනුවේ කාර්යයන් කීයක් තිබේදැයි ගණනය කිරීමට අවශ්‍ය නම් Object.keys(obj).length)

ඔව්, මම මගේ උදාහරණයේ දී nodejs වෙතින් _ හෝ අවධාරනය කරන මොඩියුලය භාවිතා කළෙමි

ප්‍රලේඛනය මෙතැනින් සොයාගත හැකිය http://underscorejs.org/ මෙන්ම එහි මූලාශ්‍රය ගිතබ් සහ වෙනත් තොරතුරු

අවසානයේ ලොඩාෂ් ක්‍රියාත්මක කිරීම https://lodash.com/docs#size

_.size(obj)

ඉහත පිළිතුරු දුන් පරිදි: Object.keys(obj).length

නමුත්: අපට දැන් ES6 හි සැබෑ සිතියම් පන්තියක් ඇති බැවින්, වස්තුවක ගුණාංග භාවිතා කිරීම වෙනුවට එය භාවිතා කිරීමට මම යෝජනා කරමි .

const map = new Map();
map.set("key", "value");
map.size; // THE fastest way

ක්‍රම තුනක් සඳහා කාර්ය සාධන පරීක්ෂණ කිහිපයක් මෙන්න;

https://jsperf.com/get-the-number-of-keys-in-an-object

Object.keys () දිග

තත්පරයට මෙහෙයුම් 20,735 කි

ඉතා සරල හා අනුකූල වේ. වේගවත් නමුත් මිල අධික ලෙස ධාවනය වන්නේ එය නව යතුරු මාලාවක් නිර්මාණය කරන නිසා එය ඉවතට විසිවන බැවිනි.

return Object.keys(objectToRead).length;

යතුරු හරහා ලූප

තත්පරයට මෙහෙයුම් 15,734 කි

let size=0;
for(let k in objectToRead) {
  size++
}
return size;

තරමක් මන්දගාමී, නමුත් මතක භාවිතය අසල කොතැනකවත් නැත, එබැවින් ඔබ ජංගම හෝ වෙනත් කුඩා යන්ත්‍ර සඳහා ප්‍රශස්තිකරණය කිරීමට කැමති නම් වඩා හොඳය

වස්තුව වෙනුවට සිතියම භාවිතා කිරීම

තත්පරයට මෙහෙයුම් 953,839,338 කි

return mapToRead.size;

මූලික වශයෙන්, සිතියම එහි ප්‍රමාණය නිරීක්ෂණය කරන බැවින් අපි සංඛ්‍යා ක්ෂේත්‍රයක් නැවත ලබා දෙන්නෙමු. වෙනත් ක්‍රමයකට වඩා බොහෝ වේගවත් ය. ඔබට වස්තුව පාලනය කළ හැකි නම්, ඒ වෙනුවට ඒවා සිතියම් බවට පරිවර්තනය කරන්න.

ඔවුන්ගේ ව්‍යාපෘතියට Underscore.js ඇතුළත් කර ඇති අයට ඔබට කළ හැක්කේ:

_({a:'', b:''}).size() // => 2

හෝ ක්‍රියාකාරී විලාසය:

_.size({a:'', b:''}) // => 2

සිට: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty

Object.defineProperty (obj, prop, descriptor)

ඔබට එය ඔබගේ සියලු වස්තු වලට එකතු කළ හැකිය:

Object.defineProperty(Object.prototype, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

හෝ තනි වස්තුවක්:

var myObj = {};
Object.defineProperty(myObj, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

උදාහරණයක්:

var myObj = {};
myObj.name  = "John Doe";
myObj.email = "leaked@example.com";
myObj.length; //output: 2

ඒ ආකාරයෙන් එකතු කළ විට, එය ලූප සඳහා පෙන්වනු නොලැබේ:

for(var i in myObj) {
     console.log(i + ":" + myObj[i]);
}

ප්‍රතිදානය:

name:John Doe
email:leaked@example.com

සටහන: එය <IE9 බ්‍රව්සර් තුළ ක්‍රියා නොකරයි.

මම මෙම ගැටළුව විසඳූ ආකාරය නම්, වස්තුව තුළ කොපමණ අයිතම ප්‍රමාණයක් ගබඩා වී ඇත්ද යන්න පිළිබඳ වාර්තාවක් තබා ගන්නා මූලික ලැයිස්තුවක් මා විසින්ම ක්‍රියාත්මක කිරීමයි. එය ඉතා සරල ය. මේ වගේ දෙයක්:

function BasicList()
{
   var items = {};
   this.count = 0;

   this.add = function(index, item)
   {
      items[index] = item;
      this.count++;
   }

   this.remove = function (index)
   {
      delete items[index];
      this.count--;
   }

   this.get = function(index)
   {
      if (undefined === index)
        return items;
      else
        return items[index];
   }
}

Object.keys(data).lengthයතුරු දත්ත ඇති JSON වස්තුවේ දිග සොයා ගැනීමට ඔබට භාවිතා කළ හැකිය

ඔවුන්ගේ ව්‍යාපෘතියේ Ext JS 4 ඇති අයට ඔබට කළ හැක්කේ:

Ext.Object.getSize(myobj);

මෙහි ඇති වාසිය නම්, එය සියලු අමතර අනුකූල බ්‍රව්සර් (IE6-IE8 ඇතුළත්) මත ක්‍රියා කරනු ඇත, කෙසේ වෙතත්, වෙනත් යෝජිත විසඳුම් මෙන්, ධාවන කාලය O (n) ට වඩා හොඳ නොවන බව මම විශ්වාස කරමි.

ඔයාට පාවිච්චි කරන්න පුළුවන්:

Object.keys(objectName).length; 

සහ

Object.values(objectName).length;

වස්තුව නෝඩ්ලිස්ට් එකක් දැයි OP නිශ්චිතව දක්වා නැත, එසේ නම් ඔබට එය මත දිග ක්‍රමය කෙලින්ම භාවිතා කළ හැකිය . උදාහරණයක්:

buttons = document.querySelectorAll('[id=button)) {
console.log('Found ' + buttons.length + ' on the screen'); 

ඉහත jQuery ක්‍රියා නොකරන්නේ නම් උත්සාහ කරන්න

$(Object.Item).length

මම මේ වගේ සියලුම වස්තු සඳහා එය ලබා දීමට උත්සාහ කරමි:

Object.defineProperty(Object.prototype, "length", {
get() {
    if (!Object.keys) {
        Object.keys = function (obj) {
            var keys = [],k;
            for (k in obj) {
                if (Object.prototype.hasOwnProperty.call(obj, k)) {
                    keys.push(k);
                }
            }
            return keys;
        };
    }
    return Object.keys(this).length;
},});

console.log({"Name":"Joe","Age":26}.length) //returns 2

මෙය කළ හැකි යැයි මම නොසිතමි (අවම වශයෙන් සමහර අභ්‍යන්තර භාවිතා නොකර). මෙය ප්‍රශස්ත කිරීමෙන් ඔබට බොහෝ වාසි ලැබෙනු ඇතැයි මම නොසිතමි.

ගූගල් වසා දැමීම මේ සඳහා හොඳ කාර්යයක් ඇත ... goog.object.getCount (obj)

goog.Object ප්‍රලේඛනය දෙස බලන්න