Skip to main content

Garbage Collection

Objects the Basics: Garbage Collection

What is garbage collection in JavaScript?​

View Answer:
Interview Response: Garbage collection in JavaScript is the automatic process of managing memory by freeing up unused memory no longer needed.

How does JavaScript manage memory manually or automatically?​

View Answer:
Interview Response: JavaScript automatically allocates memory when objects are created and clears the memory when the object no longer references it. (Garbage Collection)
note

This type of automaticity is a potential source of confusion: it can give developers the false impression that they do not need to worry about memory management.

Why is garbage collection important in JavaScript?​

View Answer:
Interview Response: Garbage collection is important in JavaScript because it prevents memory leaks and improves overall performance by managing memory automatically.

Can you explain the three steps of the memory life cycle in JavaScript?​

View Answer:
Interview Response: The memory life cycle includes allocating, using, and releasing the allocated memory when it is no longer needed.

Technical Response: The three steps in the memory life cycle include allocating memory, using the allocated memory, and releasing the allocated memory when it is no longer needed. The last part is more implicit in JavaScript than in low-level languages.


Code Example:

// allocates memory for a number
var n = 123;

// allocates memory for a string
var s = 'azerty';

// allocates memory for an object and contained values
var o = {
  a: 1,
  b: null,
};

// allocates memory for the array and contained values
var a = [1, null, 'abra'];

// allocates a function (which is a callable object)
function f(a) {
  return a + 2;
} 

// function expressions also allocate an object
someElement.addEventListener(
  'click',
  function () {
    someElement.style.backgroundColor = 'blue';
  },
  false
);

var n = null;

What is the central concept of memory management in JavaScript?​

View Answer:
Interview Response: The central concept of memory management in JavaScript is reachability. Simply put, "reachable" means values that are accessible or usable somehow and are guaranteed to be stored in memory.

Concerning JavaScript memory management. What is a GC root?​

View Answer:
Interview Response: A GC root in JavaScript is an object that is inherently accessible, like global variables. It's the starting point for garbage collection, which identifies unneeded objects to reclaim memory.

Technical Response: A "root" is simply an object that the garbage collector assumes is reachable by default, which then has its references traced to find all other current objects that are reachable. Any object that is not reachable through any reference chain of any root objects is considered unreachable and eventually gets destroyed by the garbage collector.

A base set of inherently reachable values cannot get deleted for obvious reasons. Can you name at least one?​

View Answer:
Interview Response: One inherently reachable value in JavaScript that cannot be deleted is the global object, which is the top-level object in the scope chain.

Code Example:

Before:

// global -> {nothingness}

After:

// global -> var a -> object { foo: "bar" }

null:

// global -> var a -> null
note

JavaScript cannot delete Global variables directly, and the global variable must be set to null before the memory can be collected. However, the variable still exists and references null (nothingness).

Can interlinked objects be garbage collected based on the nullification of a specific object on the GC root in JavaScript?​

View Answer:
Interview Response: Yes, the deleted or nullified object gets garbage collected even if it is part of a GC root or one of its properties references another object.

Code Example:

function marry(man, woman) {
  woman.husband = man;
  man.wife = woman;

  return {
    father: man,
    mother: woman,
  };
}

let family = marry({ name: 'John' }, { name: 'Ann' });

// if we delete both, then we can see that John has no incoming reference any more

delete family.father;
delete family.mother.husband;

Is it possible that all the interlinked objects in a root Object become unreachable and removed from memory?​

View Answer:
Interview Response: Yes, interlinked objects can be garbage collected based on the nullification of a specific object on the GC root in JavaScript, as long as they are not reachable from any other live object.

Code Example:

let family = marry(
  {
    name: 'John',
  },
  {
    name: 'Ann',
  }
);

/**
 * below the root has been nullified and all corresponding
 * interlinked objects will be garbage collected
 */

family = null;

What is the basic garbage-collection algorithm called in JavaScript?​

View Answer:
Interview Response: The basic garbage-collection algorithm in JavaScript is called Mark and Sweep. It marks live objects and sweeps away the unreachable ones.

Can you explain how the internal JavaScript garbage collector algorithm works?​

View Answer:
Interview Response: The JavaScript garbage collector uses the Mark and Sweep algorithm. It first identifies and marks all live objects, then sweeps and removes unreachable objects, and finally compacts memory to reduce fragmentation.

Technical Response:

The following "garbage collection" steps regularly get performed:

  1. The garbage collector takes roots and "marks" (remembers) them.
  2. Then it visits and "marks" all references from them.
  3. Then it visits marked objects and marks their references. The garbage collector remembers all visited objects so as not to visit the same object twice in the future.
  4. And so on until every reachable (from the roots) reference is visited.
  5. All objects except marked ones get removed.

Can you name the three standard garbage collection optimizations?​

View Answer:
Interview Response: The three standard garbage collection optimizations are generational collection, incremental collection, and idle-time collection in JavaScript.
note

You should note that each engine implements different tweaks and techniques when it comes to garbage collection.

What is the GC root in JavaScript?​

View Answer:
Interview Response: The GC root in JavaScript is the starting point for the garbage collector's traversal of objects in memory, typically including global variables.

Can global variables be garbage collected in JavaScript?​

View Answer:
Interview Response: Yes, a global variable that is equal to null is garbage collected in JavaScript. This is because the garbage collector will remove any object that is no longer referenced by any other variable. When a global variable is set to null, it no longer references any object so that it can be garbage collected.

What are some strategies for optimizing garbage collection in JavaScript?​

View Answer:
Interview Response: Strategies for optimizing garbage collection in JavaScript include minimizing global variables, avoiding circular references, utilizing weak references to objects, and reducing object creation and deletion.

How can you detect and diagnose memory leaks in JavaScript?​

View Answer:
Interview Response: We can detect and diagnose memory leaks in JavaScript by profiling memory usage, analyzing heap snapshots, using Chrome DevTools, monitoring performance, and employing garbage collection tracking.