Length of a JavaScript object

Question

I have a JavaScript object. Is there a built-in or accepted best practice way to get the length of this object?

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

Unchaste

@neitony - that's kinda true, but so many people are used to PHP's "associative array" that they might assume it means "ordered associative map", when JS objects are in fact unordered. – Ethelynethene

In the above example, myObject.length is undefined, at least in a browser environment. That's why it isn't valid, @AdrianM – Villalba

Variants of Object.{keys, values, entries}(obj).length have now been mentioned a total of 38 times in 16 answers plus in the comments of this question, and another 11 times in 7 deleted answers. I think that’s enough now. – Klepht

Answer 1

Updated answer

Here's an update as of 2016 and widespread deployment of ES5 and beyond. For IE9+ and all other modern ES5+ capable browsers, you can use Object.keys() so the above code just becomes:

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

This doesn't have to modify any existing prototype since Object.keys() is now built-in.

Edit: Objects can have symbolic properties that can not be returned via Object.key method. So the answer would be incomplete without mentioning them.

Symbol type was added to the language to create unique identifiers for object properties. The main benefit of the Symbol type is the prevention of overwrites.

Object.keys or Object.getOwnPropertyNames does not work for symbolic properties. To return them you need to use 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

Older answer

The most robust answer (i.e. that captures the intent of what you're trying to do while causing the fewest bugs) would be:

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
const myObj = {}
var size = Object.size(myObj);

There's a sort of convention in JavaScript that you don't add things to Object.prototype, because it can break enumerations in various libraries. Adding methods to Object is usually safe, though.

---

Ichthyo

@Tres - your code can be broken if someone would come and overide the 'size' property without knowing you declared it already somewhere in the code, so it's always worth checking if it's already defined – Fogbound

@Fogbound You are very correct. One should always implement necessary sanity checks :) – Ezraezri

I wrapped this answer as a jQuery plugin, for those that don't like messing around with Object: https://mcmap.net/q/37125/-length-of-a-javascript-object – Grating

@James Coglan why are you declaring the function within Object class and not just as a regular function ? i.e. function getSize(obj) {...} ? – Kirbee

@Kirbee I guess he's just maintaining proper structure. This function returns size of an object so it makes sense to make it an extension of Object. Keep your code clean and maintainable. – Togoland

This method is however more buggy, especially when hasownprop seldom clears out when deleting object keys with delete keyword. – Naarah

Why is everyone ignoring this: Object.keys(obj).length – Lepage

@MuhammadUmer Probably because that method didn't even exist when this answer was written. Even today, using it will probably require a polyfill for old browsers. – Sylphid

Re Object.keys(obj).length: That's because IE8 don't support this method. – Kirkwood

@Kirkwood IE8, IE9, IE10 are dead browsers that don't get support from Microsoft. IE8, IE9, IE10 user gets notification from Microsoft, that they use old, unsupported browser and should expect that stuff will not work for them. support.microsoft.com/en-us/kb/3123303 – Vazquez

Yeah, it's 2017. Nobody should be using anything other than Object.keys(myObj).length. This answer was correct in 2008 but not any more. – Streeter

Not sure if it has been mentioned already because TL;DR but extending JavaScript's built in objects is frowned upon. – Condorcet

Nor Object.keys() nor getOwnProperty*() functions will give you the correct answer if their parameter will be new Date(), which of course IS an object (typeof new Date() === 'object'). Freaky… – Galatea

@Galatea I don't understand what you mean. Object.keys(new Date()).length gives 0, x = new Date(); Object.keys(x).length also gives 0. – Toulon

Answer 2

If you know you don't have to worry about hasOwnProperty checks, you can use the Object.keys() method in this way:

Object.keys(myArray).length

Hulbard

why not? from what I know, it is a standard: developer.mozilla.org/en/JavaScript/Reference/Global_Objects/… – Fogbound

It's not a universally implemented method, but you can check which browser supports it with this table. – Hulbard

@Grating That depends on your requirements. – Roseboro

According to that table, IE8 supports 4 / 34 of the "standards". Wow. – Unconquerable

time to switch to firefox = unfortunately, you switching doesn't mean your website's users will... – Brucite

@Grating no IE support = time to polyfill – Besides

if (typeof Object.keys != 'function') { Object.keys = function(obj) { var ret = []; for (var x in obj) { if (obj.hasOwnProperty(x)) { ret[ret.length] = x; } } return ret; } } – Essentialism

@ripper234: No IE8, Object.keys or= (obj) -> key for own key of obj (CoffeeScript, you can easily copy generated output). – Shroudlaid

@Grating who cares about IE, no one should care about IE unstandards, only standards. users wanna use IE then they will not navigate my website I do not care any more. developers should not polyfill not standards made by ie "developers" – Longsufferance

creating a new array just to count the length of it? It's an overkill of resources – Grounder

The specification says that the keys() method returns only the names of the the object's own properties, so using this method would avoid the hasOwnProperty check. – Windpipe

@SteelBrain - Don't optimize prematurely. If you need to conserve resources then I'd recommend maintaining a separate length variable (or use a for loop) but that's probably only necessary when dealing with huge hashes. – Co

@Longsufferance That attitude won't get you far in web development. Websites are made for the visitors, not for the developers. – Garrot

Great polyfill for legacy IE at: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… – Niobium

map creates an array with the same length. Did you mean filter? – Epilogue

Even if you worried about .hasOwnProperty*() functions, you wouldn't get the right answer if the object you wanted to check against, was new Date(). – Galatea

In case speed is a concern for you it turns out Object.values(myObject).length is faster. At least in Chrome v67. gist.github.com/flekschas/5aad97d1c2520db7af0a9623deec005f – Spermogonium

Answer 3

Updated: If you're using Underscore.js (recommended, it's lightweight!), then you can just do

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

If not, and you don't want to mess around with Object properties for whatever reason, and are already using jQuery, a plugin is equally accessible:

$.assocArraySize = function(obj) {
    // https://mcmap.net/q/37125/-length-of-a-javascript-object
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

Grating

_.size() was the perfect solution for my Meteor project, which has underscore.js support. – Bookseller

I use underscore and this post just reminded me that I'm not using it enough in this project. If you handle objects, you should have underscore.js available. – Scalise

Underscore > (all -['lo-dash']) – Adjacency

underscorejs, things that should be under js :) – Pompous

Question: Why the extra if statement within the loop? – Bethesde

@Babydead to distinguish real properties of the object vs inherited ones. developer.mozilla.org/en/docs/Web/JavaScript/Reference/… – Grating

Answer 4

Here's the most cross-browser solution.

This is better than the accepted answer because it uses native Object.keys if exists. Thus, it is the fastest for all modern browsers.

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;

Plump

Object.keys() returns an array that contains the names of only those properties that are enumerable. If you want an array with ALL properties, you should use Object.getOwnPropertyNames() instead. See developer.mozilla.org/en/docs/Web/JavaScript/Reference/… – Volkan

Answer 5

Simply use this to get the length:

Object.keys(myObject).length

Behka

please explain how your answer differs from https://mcmap.net/q/37125/-length-of-a-javascript-object – Ululate

Good, it's always better to name your variables according to what they actually are. Makes your code more readable to other devs. – Satisfied

Before the "myArray" -> "myObject" edit, this was identical to the second-highest upvoted answer. – Nakasuji

Same as past responses. – Gooseflesh

Same as the linked answer, but without any explanation. – Pheasant

Answer 6

I'm not a JavaScript expert, but it looks like you would have to loop through the elements and count them since Object doesn't have a length method:

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

@palmsey: In fairness to the OP, the JavaScript documentation actually explicitly refer to using variables of type Object in this manner as "associative arrays".

Vivian

Will not work, because it will count methods too, that are added through prototype. – Citrate

Answer 7

This method gets all your object's property names in an array, so you can get the length of that array which is equal to your object's keys' length.

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

Soonsooner

@PatrickRoberts keys method doesn't return properties from prototype chain. So why the need for hasOwnProperty here. Also getOwnProperty will return hidden properties, as length is in array etc. – Lepage

Answer 8

To not mess with the prototype or other code, you could build and extend your own object:

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

If you always use the add method, the length property will be correct. If you're worried that you or others forget about using it, you could add the property counter which the others have posted to the length method, too.

Of course, you could always overwrite the methods. But even if you do, your code would probably fail noticeably, making it easy to debug. ;)

Heterogeneity

I think this is the best solution as it doesn't require looping with 'for' which could be costly if the array is big – Gaberones

Answer 9

We can find the length of Object by using:

const myObject = {};
console.log(Object.values(myObject).length);

Tittle

Theoretically, his would be slower than the "keys" method if you have long values as it is directly accessing the values then counting them. – Merited

Answer 10

Here's how and don't forget to check that the property is not on the prototype chain:

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

Parasitism

Answer 11

Here is a completely different solution that will only work in more modern browsers (Internet Explorer 9+, Chrome, Firefox 4+, Opera 11.60+, and Safari 5.1+)

See this jsFiddle.

Setup your associative array class

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

Now you can use this code as follows...

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

Polycarp

I think that is not safe. For example it cannot have an element with a key of "length", the statement a1["length"] = "Hello world"; fails to store the entry. Also the statement a1["hasOwnProperty"] = "some prop"; totaly breaks the function – Soothsay

@PanosTheof I don't think you'd want it to store the value if you used the length property, any code that used it would have to ensure it did not try and store against length, but I guess that would be the same if it was a standard array too. Overriding hasOwnProperty on any object would most likely produce an undesired result. – Polycarp

Answer 12

If you need an associative data structure that exposes its size, better use a map instead of an object.

const myMap = new Map();

myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);

console.log(myMap.size); // 3

Epilogue

Answer 13

Use Object.keys(myObject).length to get the length of object/array

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

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

Prewitt

Answer 14

Use:

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

Eirene

Answer 15

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

This works for me:

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

Stanislas

Answer 16

For some cases it is better to just store the size in a separate variable. Especially, if you're adding to the array by one element in one place and can easily increment the size. It would obviously work much faster if you need to check the size often.

Gawain

Answer 17

The simplest way is like this:

Object.keys(myobject).length

Where myobject is the object of what you want the length of.

Remaremain

This appears to be just a repeat of this existing answer. – Honeymoon

@Honeymoon agreed, and it does not provide any further context like other answers do. – Sendai

Answer 18

@palmsey: In fairness to the OP, the JavaScript documentation actually explicitly refer to using variables of type Object in this manner as "associative arrays".

And in fairness to @palmsey he was quite correct. They aren't associative arrays; they're definitely objects :) - doing the job of an associative array. But as regards to the wider point, you definitely seem to have the right of it according to this rather fine article I found:

JavaScript “Associative Arrays” Considered Harmful

But according to all this, the accepted answer itself is bad practice?

Specify a prototype size() function for Object

If anything else has been added to Object .prototype, then the suggested code will fail:

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

I don't think that answer should be the accepted one as it can't be trusted to work if you have any other code running in the same execution context. To do it in a robust fashion, surely you would need to define the size method within myArray and check for the type of the members as you iterate through them.

Intrepid

Answer 19

Using the Object.entries method to get length is one way of achieving it

const objectLength = obj => Object.entries(obj).length;

const person = {
    id: 1,
    name: 'John',
    age: 30
}
  
const car = {
    type: 2,
    color: 'red',
}

console.log(objectLength(person)); // 3
console.log(objectLength(car)); // 2

Amary

Answer 20

If we have the hash

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

we can get the length using the length of the keys which is the length of the hash:

keys(hash).length

Scrambler

This is a great answer, however I can't find any documentation for this keys function. So I can't be confident on the cross browser support. – September

Unfortunately, this is not as good an answer as I first thought! It turns out that the keys function is only available in the chrome and firefox web consoles. If you put this code in to a script then it will fail with Uncaught ReferenceError: keys is not defined – September

#32373185 – September

How is this different from aeosynth's answer? – Vitric

Answer 21

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

Lowboy

Which one is faster among the above 3. – Gyrostat

Object.values(myObject).length – Lowboy

how can we say that it Object.values(myObject).length is faster is there any example Thanks, @Lowboy – Gyrostat

just try this in console:var myObject = {}; for (let i=0; i<10000000; i++) myObject[i] = i; – Lowboy

why Object.values(myObject).length faster, where as Object.entries(myObject).length not giving output even after sometime what is the reason here ? Thanks @tdjprog – Gyrostat

On explanation would be in order. You can edit your answer. – Vitric

Answer 22

What about something like this --

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

Hoad

Answer 23

If you are using AngularJS 1.x you can do things the AngularJS way by creating a filter and using the code from any of the other examples such as the following:

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

Usage

In your controller:

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

Or in your view:

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

Unbeknown

The OP has not asked for a AngularJS version. This is not a valid answer to the question. – Garrot

Answer 24

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

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

// o/p 3

Pious

What does "o/p 3" mean? – Vitric

An explanation of this answer would be in order. – Vitric

Also, how is it different from previous answers, e.g. shaheb's answer? – Vitric

@PeterMortensen “o/p” probably means “output”. – Klepht

o/p means output – Pious

Answer 25

A variation on some of the above is:

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

It is a bit more elegant way to integrate hasOwnProp.

Pleasurable

Answer 26

If you don't care about supporting Internet Explorer 8 or lower, you can easily get the number of properties in an object by applying the following two steps:

1. Run either Object.keys() to get an array that contains the names of only those properties that are enumerable or Object.getOwnPropertyNames() if you want to also include the names of properties that are not enumerable.
2. Get the .length property of that array.

---

If you need to do this more than once, you could wrap this logic in a function:

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

How to use this particular function:

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

See also this Fiddle for a demo.

Volkan

Answer 27

Here's a different version of James Cogan's answer. Instead of passing an argument, just prototype out the Object class and make the code cleaner.

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 example: http://jsfiddle.net/qar4j/1/

Bartizan

Object.prototype - bad idea. – Hypnotherapy

@tborychowski can you please explain why? – Teenateenage

here's one article: bit.ly/1droWrG. I'm not saying it mustn't be done, only that you need to know all the repercussions before you do this. – Hypnotherapy

If you’re going to extend built-in prototypes or polyfill a property (i.e. monkey-patch), please do it correctly: for forward compatibility, check if the property exists first, then make the property non-enumerable so that the own keys of constructed objects aren’t polluted. For methods use actual methods. My recommendation: follow these examples which demonstrate how to add a method that behaves as closely as possible like built-in methods. – Klepht

Answer 28

You can always do Object.getOwnPropertyNames(myObject).length to get the same result as [].length would give for normal array.

Boutique

Object.keys() returns an array that contains the names of only those properties that are enumerable. If you want an array with ALL properties, you should use Object.getOwnPropertyNames() instead. See developer.mozilla.org/en/docs/Web/JavaScript/Reference/… – Volkan

How is this different from aeosynth's answer? – Vitric

Answer 29

You can simply use Object.keys(obj).length on any object to get its length. Object.keys returns an array containing all of the object keys (properties) which can come in handy for finding the length of that object using the length of the corresponding array. You can even write a function for this. Let's get creative and write a method for it as well (along with a more convienient getter property):

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

Sendai

How is this different from aeosynth's answer? – Vitric

It's because it shows how to make it as a function and a global object method (more object oriented and uses some form of encapsulation); however aeosynth's answer doesn't. – Sendai

If you’re going to extend built-in prototypes or polyfill a property (i.e. monkey-patch), please do it correctly: for forward compatibility, check if the property exists first, then make the property non-enumerable so that the own keys of constructed objects aren’t polluted. For methods use actual methods. My recommendation: follow these examples which demonstrate how to add a method that behaves as closely as possible like built-in methods. – Klepht

Also, how is writing a method “more efficient”? – Klepht

Answer 30

A nice way to achieve this (Internet Explorer 9+ only) is to define a magic getter on the length property:

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

And you can just use it like so:

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

It would give 1.

Latour

Arguments against prototype modification aside, I personally have NEVER had a bug caused by it and for me is one of the strong points of JavaScript. – Latour

Answer 31

Below is a version of James Coglan's answer in CoffeeScript for those who have abandoned straight JavaScript :)

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

Hem

You probably wanted to say size++ for own key of obj (own key being syntax sugar in CoffeeScript). Using hasOwnProperty directly from the object is dangerous, as it breaks when object actually has such property. – Shroudlaid

The OP didn't ask for a CoffeeScript version, nor it is tagged as such. This is not a valid answer to the question. – Garrot

Answer 32

Property

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

Use

var o = {a: 1, b: 2, c: 3};
alert(o.length); // <-- 3
o['foo'] = 123;
alert(o.length); // <-- 4

Lincolnlincolnshire

If you’re going to extend built-in prototypes or polyfill a property (i.e. monkey-patch), please do it correctly: for forward compatibility, check if the property exists first, then make the property non-enumerable so that the own keys of constructed objects aren’t polluted. For methods use actual methods. My recommendation: follow these examples which demonstrate how to add a method that behaves as closely as possible like built-in methods. – Klepht

Answer 33

With the ECMAScript 6 in-built Reflect object, you can easily count the properties of an object:

Reflect.ownKeys(targetObject).length

It will give you the length of the target object's own properties (important).

Reflect.ownKeys(target)

Returns an array of the target object's own (not inherited) property keys.

Now, what does that mean? To explain this, let's see this example.

function Person(name, age){
  this.name = name;
  this.age = age;
}

Person.prototype.getIntro= function() {
  return `${this.name} is ${this.age} years old!!`
}

let student = new Person('Anuj', 11);

console.log(Reflect.ownKeys(student).length) // 2
console.log(student.getIntro()) // Anuj is 11 years old!!

You can see here, it returned only its own properties while the object is still inheriting the property from its parent.

For more information, refer this: Reflect API

Maida

Answer 34

Try: Object.values(theObject).length

const myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;
console.log(Object.values(myObject).length);

Hawes

Answer 35

Like most JavaScript problems, there are many solutions. You could extend the Object that for better or worse works like many other languages' Dictionary (+ first class citizens). Nothing wrong with that, but another option is to construct a new Object that meets your specific needs.

function uberject(obj){
    this._count = 0;
    for(var param in obj){
        this[param] = obj[param];
        this._count++;
    }
}

uberject.prototype.getLength = function(){
    return this._count;
};

var foo = new uberject({bar:123,baz:456});
alert(foo.getLength());

Andraandrade

don't modify the prototype :) – Arguelles

Modifying the prototype of a factory function is the way you extend them. – Andraandrade

Answer 36

Simple one liner:

console.log(Object.values({id:"1",age:23,role_number:90}).length);

Prefabricate

Answer 37

Simple solution:

  var myObject = {};      // ... your object goes here.

  var length = 0;

  for (var property in myObject) {
    if (myObject.hasOwnProperty(property)){
      length += 1;
    }
  };

  console.log(length);    // logs 0 in my example.

Buonarroti

Answer 38

Here you can give any kind of varible array,object,string

function length2(obj){
    if (typeof obj==='object' && obj!== null){return Object.keys(obj).length;}
   //if (Array.isArray){return obj.length;}
    return obj.length;

}

Meg

Answer 39

Here are some methods:

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


//first method
console.log(Object.entries(myObject).length); //3

//second method
let len = 0;
for(let i in myObject)len++;
console.log(len); //3

Famous

Answer 40

The solution work for many cases and cross browser:

Code

var getTotal = function(collection) {

    var length = collection['length'];
    var isArrayObject =  typeof length == 'number' && length >= 0 && length <= Math.pow(2,53) - 1; // Number.MAX_SAFE_INTEGER

    if(isArrayObject) {
        return collection['length'];
    }

    i= 0;
    for(var key in collection) {
        if (collection.hasOwnProperty(key)) {
            i++;
        }
    }

    return i;
};

Data Examples:

// case 1
var a = new Object();
a["firstname"] = "Gareth";
a["lastname"] = "Simpson";
a["age"] = 21;

//case 2
var b = [1,2,3];

// case 3
var c = {};
c[0] = 1;
c.two = 2;

Usage

getLength(a); // 3
getLength(b); // 3
getLength(c); // 2

Pennington

Answer 41

Object.keys does not return the right result in case of object inheritance. To properly count object properties, including inherited ones, use for-in. For example, by the following function (related question):

var objLength = (o,i=0) => { for(p in o) i++; return i }

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

var child = Object.create(myObject);
child["sex"] = "male";

var objLength = (o,i=0) => { for(p in o) i++; return i }

console.log("Object.keys(myObject):", Object.keys(myObject).length, "(OK)");
console.log("Object.keys(child)   :", Object.keys(child).length, "(wrong)");
console.log("objLength(child)     :", objLength(child), "(OK)");

Hom

Answer 42

 vendor = {1: "", 2: ""}
 const keysArray = Object.keys(vendor)
 const objectLength = keysArray.length
 console.log(objectLength)
 Result 2

Awaken

A code-only answer is not high quality. While this code may be useful, you can improve it by saying why it works, how it works, when it should be used, and what its limitations are. Please edit your answer to include explanation and link to relevant documentation. – Godspeed

Answer 43

I had a similar need to calculate the bandwidth used by objects received over a websocket. Simply finding the length of the Stringified object was enough for me.

websocket.on('message', data => {
    dataPerSecond += JSON.stringify(data).length;
}

Jecon

This does not answer the question. – Theomorphic

Answer 44

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

var size = JSON.stringify(myObject).length;

document.write(size);

JSON.stringify(myObject)

Krystlekrystyna

the question resolved around the number of properties. your answer just shows what the length of one (out of many!) serialized forms is. – Interfaith

On explanation would be in order. You can edit your answer. – Vitric