Determining the Memory Footprint of JavaScript Objects

In JavaScript, understanding the memory consumption of objects is crucial for optimizing performance and avoiding memory leaks. This article addresses the query of obtaining the size of a JavaScript object, delving into a solution that estimates the approximate memory occupied by such objects.

Determining Object Size

In JavaScript, there is no built-in function specifically designed to determine the size of an object. However, a common technique involves iterating through the object's properties and calculating the size of each primitive value and object reference. This estimate considers the sizes of data types, such as boolean (4 bytes), string (length * 2 bytes), and number (8 bytes).

Implementing an Object Size Estimator

To estimate the size of a given object, a recursive function can be employed:

function roughSizeOfObject(object) {
  const objectList = [];
  const stack = [object];
  let bytes = 0;

  while (stack.length) {
    const value = stack.pop();

    switch (typeof value) {
      case 'boolean':
        bytes  = 4;
        break;
      case 'string':
        bytes  = value.length * 2;
        break;
      case 'number':
        bytes  = 8;
        break;
      case 'object':
        if (!objectList.includes(value)) {
          objectList.push(value);
          for (const prop in value) {
            if (value.hasOwnProperty(prop)) {
              stack.push(value[prop]);
            }
          }
        }
        break;
    }
  }

  return bytes;
}

Example

Using the example provided:

function Marks() {
  this.maxMarks = 100;
}

function Student() {
  this.firstName = "firstName";
  this.lastName = "lastName";
  this.marks = new Marks();
}

const stud = new Student();
const sizeInBytes = roughSizeOfObject(stud);

console.log(`Object size: ${sizeInBytes} bytes`);

In this scenario, the roughSizeOfObject function estimates the approximate memory consumption of the stud object, including its properties and nested objects.

Limitations

It's important to note that this technique provides an approximation and may not account for all memory allocations related to the object. Additionally, the overhead associated with object references and closures can introduce additional complexity in accurately determining the size.