Number of elements in a javascript object

Number of elements in a javascript object

Is there a way to get (from somewhere) the number of elements in a javascript object?? (i.e. constant-time complexity).
I cant find a property or method that retrieve that information. So far I can only think of doing an iteration through the whole collection, but that’s linear time.
It’s strange there is no direct access to the size of the object, dont you think.
I’m talking about the Object object (not objects in general):
var obj = new Object ;


Solution 1:

Although JS implementations might keep track of such a value internally, there’s no standard way to get it.

In the past, Mozilla’s Javascript variant exposed the non-standard __count__, but it has been removed with version 1.8.5.

For cross-browser scripting you’re stuck with explicitly iterating over the properties and checking hasOwnProperty():

function countProperties(obj) {
    var count = 0;

    for(var prop in obj) {

    return count;

In case of ECMAScript 5 capable implementations, this can also be written as (Kudos to Avi Flax)

function countProperties(obj) {
    return Object.keys(obj).length;

Keep in mind that you’ll also miss properties which aren’t enumerable (eg an array’s length).

If you’re using a framework like jQuery, Prototype, Mootools, $whatever-the-newest-hype, check if they come with their own collections API, which might be a better solution to your problem than using native JS objects.

Solution 2:

To do this in any ES5-compatible environment


(Browser support from here)
(Doc on Object.keys here, includes method you can add to non-ECMA5 browsers)

Solution 3:

if you are already using jQuery in your build just do this:


It works nicely for me on objects, and I already had jQuery as a dependancy.

Solution 4:

function count(){
    var c= 0;
    for(var p in this) if(this.hasOwnProperty(p))++c;
    return c;

var O={a: 1, b: 2, c: 3};;

Solution 5:

AFAIK, there is no way to do this reliably, unless you switch to an array. Which honestly, doesn’t seem strange – it’s seems pretty straight forward to me that arrays are countable, and objects aren’t.

Probably the closest you’ll get is something like this

// Monkey patching on purpose to make a point
Object.prototype.length = function()
  var i = 0;
  for ( var p in this ) i++;
  return i;

alert( {foo:"bar", bar: "baz"}.length() ); // alerts 3

But this creates problems, or at least questions. All user-created properties are counted, including the _length function itself! And while in this simple example you could avoid it by just using a normal function, that doesn’t mean you can stop other scripts from doing this. so what do you do? Ignore function properties?

Object.prototype.length = function()
  var i = 0;
  for ( var p in this )
      if ( 'function' == typeof this[p] ) continue;
  return i;

alert( {foo:"bar", bar: "baz"}.length() ); // alerts 2

In the end, I think you should probably ditch the idea of making your objects countable and figure out another way to do whatever it is you’re doing.

Solution 6:

The concept of number/length/dimensionality doesn’t really make sense for an Object, and needing it suggests you really want an Array to me.

Edit: Pointed out to me that you want an O(1) for this. To the best of my knowledge no such way exists I’m afraid.