ความยาวของวัตถุ JavaScript

ฉันมีวัตถุ JavaScript มีวิธีปฏิบัติที่ดีที่สุดในตัวหรือเป็นที่ยอมรับเพื่อให้ได้ความยาวของวัตถุนี้หรือไม่

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

มีการเรียงลำดับของการประชุมใน JavaScript ที่คุณไม่ได้เพิ่มสิ่งต่าง ๆ ใน Object.prototypeเพราะมันสามารถแยกการแจกแจงในไลบรารีต่างๆ แม้ว่าการเพิ่มวิธีการไปยังวัตถุมักจะปลอดภัย

นี่คือการอัปเดตในปี 2559 และการปรับใช้ 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;

ฉันไม่ใช่ผู้เชี่ยวชาญ JavaScript แต่ดูเหมือนว่าคุณจะต้องวนรอบองค์ประกอบและนับพวกเขาเนื่องจาก Object ไม่มีวิธีความยาว:

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

@palmsey: ในความเป็นธรรมกับ OP เอกสาร JavaScript อย่างแท้จริงอ้างถึงการใช้ตัวแปรประเภทวัตถุในลักษณะนี้เป็น "เชื่อมโยงอาร์เรย์"

วิธีนี้รับชื่อคุณสมบัติของวัตถุทั้งหมดในอาร์เรย์ดังนั้นคุณสามารถรับความยาวของอาร์เรย์นั้นซึ่งเท่ากับความยาวคีย์ของวัตถุของคุณ

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

นี่คือทางออกที่แตกต่างอย่างสิ้นเชิงที่จะทำงานเฉพาะในเบราว์เซอร์ที่ทันสมัยกว่า (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

ดูjsFiddle

ตั้งค่าคลาส Associative Array ของคุณ

/**
 * @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);

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

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

ใช้:

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

@palmsey: ในความเป็นธรรมต่อ OP เอกสาร javascript จริงอ้างถึงการใช้ตัวแปรประเภทวัตถุในลักษณะนี้เป็น "เชื่อมโยงอาร์เรย์"

และในความเป็นธรรมกับ @palmsey เขาค่อนข้างถูกต้องพวกเขาไม่ใช่อาเรย์ที่เชื่อมโยงกันพวกเขาเป็นวัตถุแน่นอน :) - ทำงานของอาเรย์ที่เชื่อมโยงกัน แต่สำหรับประเด็นที่กว้างกว่านี้คุณดูเหมือนจะมีสิทธิ์ตามที่ระบุไว้ในบทความที่ค่อนข้างดีนี้ฉันพบว่า:

JavaScript“ อาร์เรย์ที่เกี่ยวข้อง” ถือว่าเป็นอันตราย

แต่ตามที่กล่าวมาทั้งหมดคำตอบที่ได้รับการยอมรับไม่ได้เป็นสิ่งที่เลวร้ายหรือเปล่า?

ระบุขนาดต้นแบบ () ฟังก์ชั่นสำหรับวัตถุ

หากมีการเพิ่มสิ่งอื่นใน 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"};

เราสามารถรับความยาวโดยใช้ความยาวของปุ่มซึ่งเป็นความยาวของแฮช:

คีย์ (กัญชา) .length

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

1. Object.values ​​(myObject) .length
2. Object.entries (myObject) .length
3. Object.keys (myObject) .length

หากคุณใช้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>

วิธีที่ง่ายที่สุดคืออย่างนี้

Object.keys(myobject).length

ที่ myobject เป็นวัตถุของสิ่งที่คุณต้องการความยาว

หากคุณไม่สนใจเกี่ยวกับการสนับสนุน Internet Explorer 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

ดูซอนี้สำหรับการสาธิต

ใช้Object.keys(myObject).lengthเพื่อรับความยาวของวัตถุ / อาร์เรย์

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

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

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

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

// o/p 3

การเปลี่ยนแปลงในบางข้อด้านบนคือ:

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

มันเป็นวิธีที่ยอดเยี่ยมกว่าในการรวม hasOwnProp

ต่อไปนี้เป็นคำตอบของ James Cogan รุ่นอื่น แทนที่จะส่งผ่านข้อโต้แย้งเพียงแค่สร้างคลาส Object ขึ้นมาและสร้างโค้ดให้สะอาดขึ้น

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).lengthเพื่อให้ได้ผลลัพธ์เช่นเดียวกับการ[].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จะให้

ด้านล่างนี้เป็นคำตอบของ James Coglan ใน CoffeeScript สำหรับผู้ที่เลิกใช้ JavaScript โดยตรง :)

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