සම්මත වස්තු ක්රියාත්මක කිරීම ( 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;
දී ඇති පරිසරයක මෙය වේගවත් ද නැද්ද යන්න මිණුම් සලකුණු කිරීමේ ප්රශ්නයකි. කෙසේ වෙතත් ඉතා සීමිත කාර්ය සාධන ලාභයක් අපේක්ෂා කළ හැකිය.