In Javascript, when we define any variable(string, object, integer, function etc..), some memory is allocated with it and freed when they are not in use by garbage collector and this process is called garbage collection. This whole process we can define as memory life cycle:

allocation can be done by declaring a variable, function or object:

var a = 1, b = abcd; // allocating a number, string
var obj = {prop1:ex1, prop2:1} // allocate an object
var fun = function(param){
    this.param = param;
} // allocate a callable object
var arr = [apple,mango,1,2] //allocate an array

Release memory

Releasing the memory is a job of garbage collector which automatically free the memory that is no longer used by any reference.This is the general problem of knowing whether the memory is needed or not. For solving this problem we use some garbage collection algorithm. These algorithm finds the references and based on it algorithm decides whether to select object as garbage or not.

Reference counting Algorithm

This algorithm uses the concept of counting the number of references on an object, if it finds any variable having 0 reference on it algorithm selects it for garbage collection.

The mechanism which is used to make the reference 0 is:

1. When we create an object and store this in another variable its reference count is incremented to one, similarly when its reference is use in another variable or function its reference count will also be increased to two.

2. If we assign some another value to variable that was using objects reference then reference count will decrease to one. Same can be done with another variable which is using objects reference.

3. Now object is not using by any other reference, so javascript can destroy it and release its associated memory.

Example

var a = {obj:{name:"my_name"}};
var b = a;
a = 1;
//Here we created an object, which is used by variable a and b
// we have 1 to a so one of objects reference is reduced to 1
// still we have one reference which is b
b = null;
// now object has not any reference left, garbage collector will take this object.

Reference counting algo has a disadvantage of dealing with cyclic reference. When object A has a reference of object B and B has a reference of A then garbage collector will never find these object free.

var a = {};
var b = {};
a.x = b;
b.y = a;

In above condition garbage collector will not find anyone of object. For overcome to this situation most of browser support Mark-and-sweep algorithm, which uses concept of finding those object that are not in use for longer time rather to find object that has 0 reference.