Garbage Collection in JavaScript: Understanding How It Works

you may have heard of the term “garbage collection.” It is an essential concept in modern programming languages like JavaScript. It is an automated process that frees up memory occupied by objects that are no longer in use. This article will provide you with an in-depth understanding of garbage collection in JavaScript.

What is Garbage Collection?

Garbage collection is the process of freeing up memory that is no longer in use. In programming languages like JavaScript, objects are allocated memory dynamically, and the garbage collector is responsible for releasing this memory when it is no longer needed. Garbage collection is an automated process, which means that the programmer does not have to manually free up memory.

Garbage Collection Strategies:

There are two main garbage collection strategies used in modern programming languages: reference counting and tracing garbage collection.

Reference Counting:

In reference counting, every object has a counter that keeps track of how many references there are to that object. When the counter reaches zero, the object is no longer in use and can be garbage collected. The advantage of reference counting is that it can free up memory as soon as an object is no longer in use. However, it has some limitations, such as not being able to detect circular references.

Tracing Garbage Collection:

Tracing garbage collection, on the other hand, uses the mark-and-sweep algorithm. It can detect circular references and free up memory for objects that are not directly accessible from the global object. However, it has some disadvantages, such as not being able to free up memory as soon as an object is no longer in use.

How Does Garbage Collection Work in JavaScript?

The garbage collector in JavaScript uses a mark-and-sweep algorithm to determine which objects are still in use and which are not. The algorithm works in two phases: marking and sweeping.

Marking:

In the marking phase, the garbage collector identifies which objects are still in use by traversing the object graph, starting from the global object. The algorithm marks all objects that are reachable from the global object. Any objects that are not marked are considered garbage.

Sweeping:

In the sweeping phase, the garbage collector frees up the memory occupied by the garbage objects. It does this by iterating over the entire heap and deallocating memory for any objects that were not marked in the marking phase.

Example Code:

// Create a global variable for the root object
let root = window;

// Define a function to mark an object and all its descendants
function mark(obj) {
  if (obj.marked === true) {
    return;
  }

  obj.marked = true;

  // Recursively mark all properties of the object
  for (let prop in obj) {
    let value = obj[prop];
    if (typeof value === 'object' && value !== null) {
      mark(value);
    }
  }
}

// Define a function to sweep all unmarked objects from memory
function sweep() {
  for (let obj in root) {
    if (root[obj].marked !== true) {
      // Remove the object from memory
      delete root[obj];
    } else {
      // Clear the marked flag for the next cycle
      root[obj].marked = false;
    }
  }
}

// Define a function to perform garbage collection
function gc() {
  mark(root);
  sweep();
}

// Example usage:
let obj1 = {
  a: 1,
  b: {
    c: 2,
    d: {
      e: 3
    }
  }
};
let obj2 = {
  f: 4,
  g: {
    h: 5,
    i: obj1
  }
};

root.obj1 = obj1;
root.obj2 = obj2;

// Run garbage collection to free up memory
gc();

In this example, we first defined an root object to serve as the starting point for garbage collection. The mark() function recursively marks an object and all its descendants by setting a marked flag to true. The sweep() function then iterates through all objects in the root object, deleting any objects that have not been marked, and clearing the marked flag for the next cycle.

Finally, we define a gc() function to perform the mark and sweep algorithm on the root object. We can then create objects as needed and add them to the root object, running garbage collection periodically to free up memory.

Note that this is a simplified version of the Mark and Sweep algorithm and the actual implementation used in modern JavaScript engines is much more complex and efficient.

How to Prevent Memory Leaks:

A memory leak occurs when an object is not garbage collected even though it is no longer in use. To prevent memory leaks, it is essential to make sure that all references to an object are removed when it is no longer needed. This can be done by setting variables and properties to null or undefined.

Garbage collection is a critical process in modern programming languages like JavaScript. It is an automated process that frees up memory occupied by objects that are no longer in use. Understanding how garbage collection works and the different garbage collection strategies can help you write better, more optimized code. Remember to remove all references to an object when it is no longer in use to prevent memory leaks.