Should I enclose/delete variables declared in a constructor?

Question

There's something that's been bugging me about JavaScript closures. Variables created with the var keyword still exist in memory once the constructor has completed its execution. Example:

function RangeCalculator(values) {
  var min = Infinity;
  var max = -Infinity;
  for (var i = 0; i < values.length; ++i) {
    min = Math.min(min, values[i]);
    max = Math.max(max, values[i]);
  }

  this.range = max - min;
  
  this.getMin = function() {
    return min;
  };
  this.getMax = function() {
    return max;
  };
}

r = new RangeCalculator([1, 2, 3, 4, 5]);
console.log("min: " + r.getMin() + ", max: " + r.getMax());

<p>Check the console</p>

In that code, min and max aren't accessible from anywhere except functions defined within the constructor. This allows making private member variables in JavaScript.

But what if I just wanted to use the min and max variables to help me count the range, but didn't need them afterward. What if I remove the getMin and getMax functions. Will all the var-declared variables used in the constructor still exist and take space in memory, including the i from the for loop?

What if I wrap that code in a self-executing anonymous function?

function RangeCalculator(values) {
    (function (t) {
        var min = Infinity;
        var max = -Infinity;
        for (var i = 0; i < values.length; ++i) {
            min = Math.min(min, values[i]);
            max = Math.max(max, values[i]);
        }
        t.range = max - min;
    })(this);
}

var r = new RangeCalculator([1, 2, 3, 4, 5]);
alert(r.range);

possible duplicate of [How JavaScript closures are garbage collected](http://stackoverflow.com/questions/19798803/how-javascript-closures-are-garbage-collected) — ekuusela, May 04 '15 at 20:31
@ekuusela Thanks for that. From what I understand, this means browsers will always keep the closure in memory, or at least it will if there's a function which was declared inside the constructor. http://jsfiddle.net/gqpsv7z0/ — Domino, May 05 '15 at 13:11
I did change the example of the OP as a fiddle too - http://jsfiddle.net/gqpsv7z0/1/. The inner IIFE of the constructor should be garbage collected after construction time for it does not keep alive any references and returns a primitive value only. (In comparison the OP example's IIFE holds the constructors `this` reference forever as `t`.) Thus creating a `RangeCalculator` instance in the latter example should be as low in memory consumption as possible and also sticking very close to the OP's example. — Peter Seliger, May 09 '15 at 13:45

Peter Seliger · Answer 1 · 2015-05-05T01:17:41.323

If information hiding is part of the custom type's concept, then the answer is definitely yes. Nevertheless a constructor should always be implemented as most lightweight as possible. All additional build logic should be part of a factory method. The given example code could be refactored towards something similar like the following ...

var NumberRange = (function (global) {

    var
        Number    = global.Number,
        Math      = global.Math,

        math_min  = Math.min,
        math_max  = Math.max,

        MIN_VALUE = Number.NEGATIVE_INFINITY,
        MAX_VALUE = Number.POSITIVE_INFINITY,

        collectLimitingValues = function (collector, value) {
            collector.minValue = math_min(collector.minValue, value);
            collector.maxValue = math_max(collector.maxValue, value);
            return collector;
        },


        NumberRange = function NumberRange (min, max) {
            this.range = (max - min);

            this.getMin = function () {
                return min;
            };
            this.getMax = function () {
                return max;
            };
        },


        createNumberRange = function (numberValueList) {

        //  right place for sanitizing all arguments.

            var rangeLimitMap = numberValueList.reduce(
                collectLimitingValues, {
                    minValue: MAX_VALUE,
                    maxValue: MIN_VALUE,
                }
            );
            return (new NumberRange(
                rangeLimitMap.minValue,
                rangeLimitMap.maxValue
            ));
        }
    ;

    return {
        create: createNumberRange
    };

}(window));


var r = NumberRange.create([1, 2, 3, 4, 5]);
console.log("min: " + r.getMin() + ", max: " + r.getMax());

<p>Check the console</p>

For this exact situation I won't be making a factory object, but thanks for reminding me about them. — Domino, May 05 '15 at 12:58

Should I enclose/delete variables declared in a constructor?

1 Answers1