You want to determine the length of a JavaScript object, which is the number of properties in an object. Properties are also referred to as keys. Regular JavaScript objects don’t have a length
property, which is a property of an array. How do you determine the length of an object?
Convert the object to an array so that you can use the array length
property to determine the number of properties in the object. The Object.keys()
method is suitable for most use cases.
Object.keys()
MethodThe Object.keys()
method takes in an object as an argument and returns an array of the object’s properties:
const obj = { name: 'Ben', age: 30, job: 'doctor' }; const arrFromObj = Object.keys(obj); console.log(arrFromObj.length); // 3
This method is relatively new: it was added to the ES6 JavaScript language update. The Object.keys()
method does not necessarily return all of the properties in an object. It returns an object’s own enumerable string-keyed property names.
You can also use the Object.values()
method to return an array of the object’s values or the Object.entries()
method to return an array containing the object’s key-value pairs. Each key-value pair is added to a nested array.
Object.getOwnPropertyNames()
MethodIf you need to count non-enumerable properties, you can use the Object.getOwnPropertyNames()
method. It’s similar to the Object.keys()
method in that it returns an array of the properties of an object. The difference is that it also returns non-enumerable properties, except for properties that use a symbol type.
const obj = { name: 'Ben', age: 30, job: 'doctor' }; const arrFromObj = Object.getOwnPropertyNames(obj); console.log(arrFromObj.length); // 3
You can also use a for...in
loop to iterate through an object’s enumerable properties and then use a variable that increments on each loop to count the number of properties:
const obj = { name: 'Ben', age: 30, job: 'doctor' }; let length = 0; for (const key in obj) { length++; } console.log(length); // 3
Various other methods can be used to count properties, enumerable or non-enumerable, of an object as can be seen in this table: Transversing JavaScript properties.