ජාවාස්ක්‍රිප්ට් වස්තුවක දිග

මට ජාවාස්ක්‍රිප්ට් වස්තුවක් තිබේ, මෙම වස්තුවේ දිග ලබා ගැනීම සඳහා ගොඩනංවන ලද හෝ පිළිගත් හොඳම පුහුණු ක්‍රමයක් තිබේද?

const myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

වඩාත්ම ශක්තිමත් පිළිතුර (එනම් අඩුම දෝෂ ඇති කරන අතරතුර ඔබ කිරීමට උත්සාහ කරන දෙයෙහි අභිප්‍රාය ග්‍රහණය කරගනී):

Object.size = function(obj) {
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

// Get the size of an object
var size = Object.size(myObj);

ජාවාස්ක්‍රිප්ට් හි යම් ආකාරයක සම්මුතියක් ඇත, ඔබ Object.prototype වෙත දේවල් එකතු නොකරයි , එයට විවිධ පුස්තකාලවල ගණන් කිරීම් බිඳ දැමිය හැකිය. වස්තුවට ක්‍රම එකතු කිරීම සාමාන්‍යයෙන් ආරක්ෂිතයි.

මෙන්න 2016 වන විට යාවත්කාලීන කිරීමක් සහ ES5 සහ ඉන් ඔබ්බට පුළුල් ලෙස යෙදවීම . IE9 + සහ අනෙකුත් සියලුම නවීන ES5 + හැකියාව ඇති බ්‍රව්සර් සඳහා, ඔබට භාවිතා කළ හැකි Object.keys()බැවින් ඉහත කේතය පහත පරිදි වේ:

var size = Object.keys(myObj).length;

මෙය Object.keys()දැනට ගොඩනගා ඇති බැවින් දැනට පවතින කිසිදු මූලාකෘතියක් වෙනස් කිරීමට අවශ්‍ය නොවේ .

සංස්කරණය කරන්න : වස්තු වලට සංකේතාත්මක ගුණාංග තිබිය හැකි අතර ඒවා Object.key ක්‍රමය හරහා ආපසු ලබා දිය නොහැක. එබැවින් ඒවා සඳහන් නොකර පිළිතුර අසම්පූර්ණ වනු ඇත.

වස්තු ගුණාංග සඳහා අද්විතීය හඳුනාගැනීම් නිර්මාණය කිරීම සඳහා භාෂාවට සංකේත වර්ගය එක් කරන ලදි. සංකේත වර්ගයේ ප්‍රධාන වාසිය වන්නේ නැවත ලිවීම වැළැක්වීමයි.

Object.keysහෝ Object.getOwnPropertyNamesසංකේතාත්මක ගුණාංග සඳහා ක්‍රියා නොකරයි. ඒවා ආපසු ලබා දීමට ඔබ භාවිතා කළ Object.getOwnPropertySymbolsයුතුය.

var person = {
  [Symbol('name')]: 'John Doe',
  [Symbol('age')]: 33,
  "occupation": "Programmer"
};

const propOwn = Object.getOwnPropertyNames(person);
console.log(propOwn.length); // 1

let propSymb = Object.getOwnPropertySymbols(person);
console.log(propSymb.length); // 2

hasOwnPropertyචෙක්පත් ගැන කරදර විය යුතු නැති බව ඔබ දන්නේ නම් , ඔබට මෙය ඉතා සරලව කළ හැකිය:

Object.keys(myArray).length

යාවත්කාලීන කරන ලද්දේ : ඔබ Underscore.js භාවිතා කරන්නේ නම් (නිර්දේශිතයි, එය සැහැල්ලුයි!), එවිට ඔබට කළ හැකිය

_.size({one : 1, two : 2, three : 3});
=> 3

එසේ නොවේ නම් , සහ ඔබට කිසියම් හේතුවක් නිසා වස්තු ගුණාංග සමඟ පටලවා ගැනීමට අවශ්‍ය නැති අතර දැනටමත් jQuery භාවිතා කරමින් සිටී නම්, ප්ලගිනයක් සමානව ප්‍රවේශ විය හැකිය:

$.assocArraySize = function(obj) {
    // http://stackoverflow.com/a/6700/11236
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

මෙන්න වඩාත්ම හරස් බ්රවුසර විසඳුම.

මෙය පිළිගත් පිළිතුරට වඩා හොඳය, මන්ද එය පවතින්නේ නම් ස්වදේශීය Object.keys භාවිතා කරයි. මේ අනුව, එය සියලු නවීන බ්‍රව්සර් සඳහා වේගවත්ම වේ.

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

Object.keys(obj).length;

මම ජාවාස්ක්‍රිප්ට් විශේෂ expert යෙක් නොවෙමි, නමුත් ඔබට පෙනෙන්නේ මූලද්‍රව්‍යයන් හරහා ඒවා ගණනය කර වස්තුවට දිග ක්‍රමයක් නොමැති බැවින් ඒවා ගණන් කළ යුතු බවයි:

var element_count = 0;
for (e in myArray) {  if (myArray.hasOwnProperty(e)) element_count++; }

alpalmsey: OP ට සාධාරණයක් ලෙස, ජාවාස්ක්‍රිප්ට් ප්‍රලේඛනය ඇත්ත වශයෙන්ම පැහැදිලිවම සඳහන් කරන්නේ මේ ආකාරයෙන් වස්තු වර්ගයේ විචල්‍යයන් “සහායක අරා” ලෙස භාවිතා කිරීමයි.

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

Object.getOwnPropertyNames({"hi":"Hi","msg":"Message"}).length; // => 2

මූලාකෘති හෝ වෙනත් කේත සමඟ පටලවා නොගැනීමට, ඔබට ඔබේම වස්තුවක් සාදා දිගු කළ හැකිය:

function Hash(){
    var length=0;
    this.add = function(key, val){
         if(this[key] == undefined)
         {
           length++;
         }
         this[key]=val;
    }; 
    this.length = function(){
        return length;
    };
}

myArray = new Hash();
myArray.add("lastname", "Simpson");
myArray.add("age", 21);
alert(myArray.length()); // will alert 2

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

ඇත්ත වශයෙන්ම, ඔබට සෑම විටම ක්රම නැවත ලිවිය හැකිය. නමුත් ඔබ එසේ කළත්, ඔබේ කේතය සැලකිය යුතු ලෙස අසමත් වන අතර එය නිදොස් කිරීම පහසු කරයි. ;)

දේපල මූලාකෘති දාමයේ නොමැති බව පරීක්ෂා කිරීමට මෙන්න සහ අමතක නොකරන්න:

var element_count = 0;
for(var e in myArray)
    if(myArray.hasOwnProperty(e))
        element_count++;

මෙය ලබා ගැනීමට මෙය භාවිතා කරන්න length:

Object.keys(myObject).length

<script>
myObj = {"key1" : "Hello", "key2" : "Goodbye"};
var size = Object.keys(myObj).length;
console.log(size);
</script>

<p id="myObj">The number of <b>keys</b> in <b>myObj</b> are: <script>document.write(size)</script></p>

මෙය මට වැඩ කරයි:

var size = Object.keys(myObj).length;

මෙන්න සම්පූර්ණයෙන්ම වෙනස් විසඳුමක් වන අතර එය වඩාත් නවීන බ්‍රව්සර්වල පමණක් ක්‍රියා කරයි (IE9 +, ක්‍රෝම්, ෆයර්ෆොක්ස් 4+, ඔපෙරා 11.60+, සෆාරි 5.1+)

JsFiddle බලන්න

ඔබේ ඇසෝසියේටිව් අරා පන්තිය සකසන්න

/**
 * @constructor
 */
AssociativeArray = function () {};

// Make the length property work
Object.defineProperty(AssociativeArray.prototype, "length", {
    get: function () {
        var count = 0;
        for (var key in this) {
            if (this.hasOwnProperty(key))
                count++;
        }
        return count;
    }
});

දැන් ඔබට මෙම කේතය පහත පරිදි භාවිතා කළ හැකිය ...

var a1 = new AssociativeArray();
a1["prop1"] = "test";
a1["prop2"] = 1234;
a1["prop3"] = "something else";
alert("Length of array is " + a1.length);

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

භාවිත:

var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
obj = Object.keys(myArray).length;
console.log(obj)

alm පැල්ම්සි: OP ට සාධාරණයක් ලෙස, ජාවාස්ක්‍රිප්ට් ලියකියවිලි ඇත්ත වශයෙන්ම පැහැදිලිවම සඳහන් කරන්නේ වස්තු වර්ගයේ විචල්‍යයන් මේ ආකාරයෙන් “සහායක අරා” ලෙස භාවිතා කිරීමයි.

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

ජාවාස්ක්‍රිප්ට් “ඇසෝසියේටිව් අරා” හානිකර ලෙස සැලකේ

නමුත් මේ සියල්ලට අනුව, පිළිගත් පිළිතුර නරක පුරුද්දක් නොවේද?

වස්තුව සඳහා මූලාකෘති ප්‍රමාණයේ () ශ්‍රිතයක් සඳහන් කරන්න

Object .prototype වෙත වෙනත් යමක් එකතු කර ඇත්නම්, එවිට යෝජිත කේතය අසාර්ථක වනු ඇත:

<script type="text/javascript">
Object.prototype.size = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
Object.prototype.size2 = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
alert("age is " + myArray["age"]);
alert("length is " + myArray.size());
</script>

එකම ක්‍රියාත්මක කිරීමේ සන්දර්භය තුළ ඔබට වෙනත් කේතයක් තිබේ නම් එය ක්‍රියාත්මක කිරීම විශ්වාස කළ නොහැකි බැවින් එම පිළිතුර පිළිගත් පිළිතුර විය යුතු යැයි මම නොසිතමි. එය ශක්තිමත් ආකාරයකින් සිදු කිරීම සඳහා නියත වශයෙන්ම ඔබට myArray තුළ ඇති ප්‍රමාණයේ ක්‍රමය නිර්වචනය කළ යුතු අතර ඔබ ඔවුන් හරහා ගමන් කරන විට සාමාජිකයින්ගේ වර්ගය පරීක්ෂා කරන්න.

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

const myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3

මේ වගේ දෙයක් ගැන -

function keyValuePairs() {
    this.length = 0;
    function add(key, value) { this[key] = value; this.length++; }
    function remove(key) { if (this.hasOwnProperty(key)) { delete this[key]; this.length--; }}
}

අපට හැෂ් තිබේ නම්

hash = {"a": "b", "c": "d"};

හෑෂ් වල දිග වන යතුරු වල දිග භාවිතා කර අපට දිග ලබා ගත හැකිය:

යතුරු (හැෂ්). දිග

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

1. Object.values ​​(myObject). දිග
2. Object.entries (myObject). දිග
3. Object.keys (myObject). දිග

සරලම ක්‍රමය මේ වගේ ය

Object.keys(myobject).length

එහිදී myobject යනු ඔබට අවශ්‍ය දිග ප්‍රමාණයයි

ඔබ AngularJS 1.x භාවිතා කරන්නේ නම්, ඔබට පෙරනයක් නිර්මාණය කිරීමෙන් සහ පහත දැක්වෙන වෙනත් උදාහරණ වලින් කේතය භාවිතා කිරීමෙන් AngularJS ක්‍රමයට දේවල් කළ හැකිය:

// Count the elements in an object
app.filter('lengthOfObject', function() {
  return function( obj ) {
    var size = 0, key;
    for (key in obj) {
      if (obj.hasOwnProperty(key)) size++;
    }
   return size;
 }
})

භාවිතය

ඔබේ පාලකය තුළ:

$scope.filterResult = $filter('lengthOfObject')($scope.object)

හෝ ඔබේ මතය අනුව:

<any ng-expression="object | lengthOfObject"></any>

const myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

console.log(Object.keys(myObject).length)

// o/p 3

Object.keys(myObject).lengthවස්තුව / අරාවෙහි දිග ලබා ගැනීමට භාවිතා කරන්න

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

console.log(Object.keys(myObject).length); //3

ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8 හෝ ඊට අඩු සහය දැක්වීම ගැන ඔබ තැකීමක් නොකරන්නේ නම්, පහත දැක්වෙන පියවර දෙක අනුගමනය කිරීමෙන් ඔබට පහසුවෙන් වස්තුවක ඇති දේපල ගණන ලබා ගත හැකිය:

1. ධාවනය හෝ Object.keys()සිටින බව එම ගුණ පමණක් නම් අඩංගු වන බව මාලාවක් ලබා ගැනීමට ගණ්ය හෝ Object.getOwnPropertyNames()ඔබ ද ගණ්ය නොවන බව ගුණ නම් ඇතුළත් කිරීමට අවශ්ය නම්.
2. .lengthඑම අරාවෙහි දේපල ලබා ගන්න .

ඔබට මෙය එක් වරකට වඩා කිරීමට අවශ්‍ය නම්, ඔබට මෙම තර්කනය ශ්‍රිතයක් තුළට ඔතා ගත හැකිය:

function size(obj, enumerablesOnly) {
    return enumerablesOnly === false ?
        Object.getOwnPropertyNames(obj).length :
        Object.keys(obj).length;
}

මෙම විශේෂිත ශ්‍රිතය භාවිතා කරන්නේ කෙසේද:

var myObj = Object.create({}, {
    getFoo: {},
    setFoo: {}
});
myObj.Foo = 12;

var myArr = [1,2,5,4,8,15];

console.log(size(myObj));        // Output : 1
console.log(size(myObj, true));  // Output : 1
console.log(size(myObj, false)); // Output : 3
console.log(size(myArr));        // Output : 6
console.log(size(myArr, true));  // Output : 6
console.log(size(myArr, false)); // Output : 7

නිරූපණයක් සඳහා මෙම ෆෙඩෙල් ද බලන්න .

ඉහත සමහරක් මත විචලනය වන්නේ:

var objLength = function(obj){    
    var key,len=0;
    for(key in obj){
        len += Number( obj.hasOwnProperty(key) );
    }
    return len;
};

HasOwnProp ඒකාබද්ධ කිරීම සඳහා එය තව ටිකක් අලංකාර ක්‍රමයකි.

ජේම්ස් කොගන්ගේ පිළිතුරේ වෙනස් අනුවාදයක් මෙන්න. තර්කයක් සම්මත කරනවා වෙනුවට, වස්තු පන්තිය මූලාකෘති කොට කේතය පිරිසිදු කරන්න.

Object.prototype.size = function () {
    var size = 0,
        key;
    for (key in this) {
        if (this.hasOwnProperty(key)) size++;
    }
    return size;
};

var x = {
    one: 1,
    two: 2,
    three: 3
};

x.size() === 3;

jsfiddle උදාහරණය: http://jsfiddle.net/qar4j/1/

Object.keys(obj).lengthඕනෑම වස්තුවක දිග ලබා ගැනීම සඳහා ඔබට එය භාවිතා කළ හැකිය . Object.keys විසින් අනුරූපී අරාවෙහි දිග භාවිතා කරමින් එම වස්තුවේ දිග සොයා ගැනීම සඳහා ප්‍රයෝජනවත් විය හැකි සියලුම වස්තු යතුරු (ගුණාංග) අඩංගු අරාවක් ලබා දෙයි. ඔබට මේ සඳහා ශ්‍රිතයක් පවා ලිවිය හැකිය . අපි නිර්මාණශීලී වී ඒ සඳහා ක්‍රමවේදයක් ලියමු (වඩාත් සුවපහසු දේපළක් සමඟ):

function objLength(obj)
{
  return Object.keys(obj).length;
}

console.log(objLength({a:1, b:"summit", c:"nonsense"}));

// Works perfectly fine
var obj = new Object();
obj['fish'] = 30;
obj['nullified content'] = null;
console.log(objLength(obj));

// It also works your way, which is creating it using the Object constructor
Object.prototype.getLength = function() {
   return Object.keys(this).length;
}
console.log(obj.getLength());

// You can also write it as a method, which is more efficient as done so above

Object.defineProperty(Object.prototype, "length", {get:function(){
    return Object.keys(this).length;
}});
console.log(obj.length);

// probably the most effictive approach is done so and demonstrated above which sets a getter property called "length" for objects which returns the equivalent value of getLength(this) or this.getLength()

සාමාන්‍ය අරාව සඳහා ලබා දෙන ප්‍රති Object.getOwnPropertyNames(myObject).lengthresult ලය ලබා ගැනීමට ඔබට සැමවිටම කළ හැකිය [].length.

භාවිතා කිරීමෙන් අපට වස්තුවේ දිග සොයාගත හැකිය:

Object.values(myObject).length

ක්‍රීඩාවට ටිකක් ප්‍රමාදයි, නමුත් මෙය සාක්ෂාත් කර ගැනීම සඳහා හොඳ ක්‍රමයක් (IE9 + පමණි) යනු දිග දේපල මත මැජික් ලබා ගන්නෙකු නිර්වචනය කිරීමයි:

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

ඔබට එය එසේ භාවිතා කළ හැකිය:

var myObj = { 'key': 'value' };
myObj.length;

දෙන්නම් 1.

කෙලින්ම ජාවාස්ක්‍රිප්ට් අතහැර දමා ඇති අය සඳහා කෝපි ස්ක්‍රිප්ට් හි ජේම්ස් කොග්ලන් දුන් පිළිතුරේ පිටපතක් පහත දැක්වේ :)

Object.size = (obj) ->
  size = 0
  size++ for own key of obj
  size