Some de-reference
common errors

It is better to set "null".

Only when the last reference to an object is removed, is that object eligible for collection.

function SlowPurchase(units, price) {
    this.units = units;
    this.price = price;
    this.total = 0;
    this.x = 1;
}
var slow = new SlowPurchase(3, 25);
//x property is useless 
//so I delete it
delete slow.x; 
    

"slow" should be using a smaller memory footprint than "fast" (1 less property), shouldn't it?

function FastPurchase(units, price) {
    this.units = units;
    this.price = price;
    this.total = 0;
    this.x = 1;
}
var fast = new FastPurchase(3, 25);

 
    

"fast" objects are faster

Timers are a very common source of memory leaks.

Look at the following code:

If we run:

With this we have a memory leak:

When is the #tree GC?

var select = document.querySelector;
var treeRef = select("#tree");
var leafRef = select("#leaf");
var body = select("body");
body.removeChild(treeRef);
//#tree can't be GC yet due to treeRef
treeRef = null;
//#tree can't be GC yet, due to 
//indirect reference from leafRef
leafRef = null;
//NOW can be #tree GC

#leaf maintains a reference to it's parent (parentNode), and recursively up to #tree, so only when leafRef is nullified is the WHOLE tree under #tree candidate to be GC

It helps a lot to name the functions, so you easily distinguish between closures in the snapshot.

function createLargeClosure() {
    var largeStr = new Array(1000000).join('x');
    
    var lC =  function() { //this IS NOT a named function
        return largeStr;
    };
    return lC;
}

function createLargeClosure() {
    var largeStr = new Array(1000000).join('x');
    var lC = function lC() { //this IS a named function
        return largeStr;
    };
    return lC;
}