วิธีการนับจำนวนคีย์ / คุณสมบัติของวัตถุใน JavaScript อย่างมีประสิทธิภาพ

วิธีที่เร็วที่สุดในการนับจำนวนคีย์ / คุณสมบัติของวัตถุคืออะไร เป็นไปได้ไหมที่จะทำได้โดยไม่ต้องวนซ้ำวัตถุ? ie โดยไม่ต้องทำ

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

(Firefox ให้__count__คุณสมบัติที่เป็นเวทมนตร์แต่สิ่งนี้ถูกลบออกไปรอบ ๆ เวอร์ชัน 4)

หากต้องการทำสิ่งนี้ในสภาพแวดล้อมที่รองรับ ES5เช่นNode , Chrome, IE 9+, Firefox 4+ หรือ Safari 5+:

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 (ขอบคุณ @douwe):
_.size(obj)

หรือคุณสามารถใช้_.keysซึ่งอาจชัดเจนสำหรับบางคน:
_.keys(obj).length

ฉันขอแนะนำ Underscore เป็นห้องสมุดที่แน่นสำหรับการทำสิ่งพื้นฐานมากมาย เมื่อใดก็ตามที่เป็นไปได้พวกเขาจะจับคู่ ECMA5 และเลื่อนไปสู่การปฏิบัติตามท้องถิ่น

มิฉะนั้นฉันจะสนับสนุนคำตอบของ @ Avi ฉันแก้ไขมันเพื่อเพิ่มลิงค์ไปยัง MDC doc ซึ่งมีปุ่ม () วิธีการที่คุณสามารถเพิ่มไปยังเบราว์เซอร์ที่ไม่ใช่ ECMA5

การใช้งานวัตถุมาตรฐาน ( คุณสมบัติและวิธีการภายในวัตถุของ ES5.1 ) ไม่จำเป็นต้องมีObjectการติดตามจำนวนของคีย์ / คุณสมบัติดังนั้นจึงไม่มีวิธีมาตรฐานในการกำหนดขนาดของObjectโดยไม่มีการวนซ้ำอย่างชัดเจนหรือโดยปริยาย

ดังนั้นนี่คือทางเลือกที่ใช้บ่อยที่สุด:

1. Object.keys ของ ECMAScript ()

Object.keys(obj).length;ทำงานโดยการวนซ้ำภายในคีย์เพื่อคำนวณอาร์เรย์ชั่วคราวและส่งคืนความยาว

• ข้อดี - ไวยากรณ์ที่อ่านได้และทำความสะอาด ไม่จำเป็นต้องใช้ไลบรารีหรือรหัสที่กำหนดเองยกเว้น shim หากการสนับสนุนดั้งเดิมไม่พร้อมใช้งาน
• Cons - โอเวอร์เฮดหน่วยความจำเนื่องจากการสร้างอาเรย์

2. โซลูชันบนห้องสมุด

ตัวอย่างจากห้องสมุดหลายแห่งในหัวข้อนี้เป็นสำนวนที่มีประโยชน์ในบริบทของห้องสมุด อย่างไรก็ตามจากมุมมองประสิทธิภาพการทำงานไม่มีอะไรที่จะได้รับเมื่อเทียบกับโค้ดที่ไม่มีไลบรารีที่สมบูรณ์แบบเนื่องจากเมธอดไลบรารีทั้งหมดนั้นห่อหุ้มแบบ for-loop หรือ ES5 Object.keys(native หรือ shimmed)

3. การปรับให้เหมาะสมสำหรับ for-loop

ส่วนที่ช้าที่สุดของ for-loop นั้นโดยทั่วไปแล้วเป็นการ.hasOwnProperty()เรียกเนื่องจากการเรียกใช้ฟังก์ชัน ดังนั้นเมื่อผมต้องการเพียงแค่จำนวนของรายการของวัตถุ JSON ที่ฉันเพิ่งข้ามโทรถ้าฉันรู้ว่ารหัสไม่ได้หรือจะขยาย.hasOwnProperty() Object.prototype

มิฉะนั้นรหัสของคุณอาจได้รับการปรับให้เหมาะสมเล็กน้อยโดยการกำหนดklocal ( var k) และโดยใช้ตัวดำเนินการเพิ่มคำนำหน้า ( ++count) แทน postfix

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)และใช้งาน

ตามที่ระบุโดย Avi Flax 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__และถ้ามันไม่มีอยู่ (เช่นไม่ใช่ Firefox) จากนั้นคุณสามารถทำซ้ำวัตถุและกำหนด เพื่อใช้ในภายหลังเช่น:

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 ให้คำตอบ Object.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/เช่นเดียวกับแหล่งที่มาของ GitHub และข้อมูลอื่น ๆ อีกมากมาย

และในที่สุดก็ทำการติดตั้งhttps://lodash.com/docs#size

_.size(obj)

ตามคำตอบข้างต้น: Object.keys(obj).length

แต่: เนื่องจากเรามีคลาสMapจริงใน ES6 ฉันจึงแนะนำให้ใช้แทนการใช้คุณสมบัติของวัตถุ

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

สำหรับผู้ที่มี Underscore.js รวมอยู่ในโครงการของพวกเขาคุณสามารถทำได้:

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

หรือสไตล์การทำงาน:

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

ต่อไปนี้เป็นการทดสอบประสิทธิภาพสำหรับสามวิธี

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;

โดยทั่วไปแผนที่จะติดตามขนาดของมันเองดังนั้นเราจึงเพิ่งคืนค่าฟิลด์ตัวเลข ไกลเร็วกว่าวิธีอื่นใด หากคุณมีการควบคุมวัตถุให้แปลงเป็นแผนที่แทน

จาก: 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);

ข้อดีของการทำเช่นนี้คือมันจะทำงานบนเบราว์เซอร์ที่ใช้งานร่วมกันได้ Ext ทั้งหมด (รวม IE6-IE8) แต่ฉันเชื่อว่าเวลาใช้งานไม่ดีกว่า O (n) เช่นเดียวกับโซลูชันที่แนะนำอื่น ๆ

คุณสามารถใช้ได้:

Object.keys(objectName).length; 

และ

Object.values(objectName).length;

OP ไม่ได้ระบุว่าวัตถุนั้นเป็น nodeList หรือไม่หากเป็นเช่นนั้นคุณสามารถใช้วิธียาวกับมันโดยตรง ตัวอย่าง:

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

Google Closure มีฟังก์ชั่นที่ดีสำหรับสิ่งนี้ ... goog.object.getCount (obj)

ดูที่ goog.Object Documentation