Question

I would like to make an extendDeep() function that does not make any garbage for GC.

The garbage collector need to be as inactive as possible.
ref.: https://www.scirra.com/blog/76/how-to-write-low-garbage-real-time-javascript

This is the extendDeep() function I want to modify:

function extendDeep(parent, child) {
    var i, toStr = Object.prototype.toString,
        astr = "[object Array]";

    child = child || {};

    for (i in parent) {
        if (parent.hasOwnProperty(i)) {
            if (typeof parent[i] === 'object') {
                child[i] = (toStr.call(parent[i]) === astr) ? [] : {};
                extendDeep(parent[i], child[i]);
            } else {
                child[i] = parent[i];
            }
        }
    }
    return child;
}

The function does not have to return anything. since the retuned object is why the garbage is made.

It is assumed that all the propertis of the parent object is available by reference (reuse of objects)

Answer 1

This is actually a more interesting question than I first thought. After reading the suggested link it is clear the articles author is advocating object pooling. So something like

function Pool(fConstructor, nMaxSize, fCleanFunction) {
    this.aObjectPool = [];
    this.nMaxSize = nMaxSize;
    this.fCleanFunction = fCleanFunction;
    this.fConstructor = fConstructor;
}

Pool.prototype.get = function() {
    return this.aObjectPool.pop() || new this.fConstructor();
}

Pool.prototype.recycle = function(oObject) {
    if (aObjectPool.length < this.nMaxSize) {
        fCleanFunction(oObject);
        this.aObjectPool.push(oObject);
    }
}       

function wipeArray(aArray) {
    aArray.length = 0;
}

function wipeObject(oObject) {
    for (var p in obj) {
        if (obj.hasOwnProperty(p)) {
            delete obj[p];
        }
    }
};

var oArrayPool = new Pool(Array, 50, wipeArray);

var oObjectPool = new Pool(Object, 50, wipeObject);

could be used to implement the pool. Then you’d replace the []’s and {}’s in the extend deep function with pool.get()’s.

Of course, for this to work you’d also need to ensure you were recycling old objects and arrays rather than just leaving them for garbage collection.