Where should I define my Javascript closure?

Question

I'm creating my own JavaScript Array-like object and I have methods that call closures. I was just wondering where was the most efficient place to define a closure.

For example, imagine I have a map function and a chop function:

MyObject.prototype = 
{
  map: function(fn) { ... applies fn to each element ... };

  chop: function() 
  { this.map( 
    function(element) 
    {
      ... chop off last character ... 
    } 
  )};
}

Is it more efficient to do this instead?

MyObject.prototype = 
{
  map: function(fn) { ... applies fn to each element ... };

  __chop: function(element) 
  {
    ... chop off last character ... 
  }

  chop: function() 
  { this.map(this.__chop) };
}

Answer 1

They are effectively the same thing - go with whichever one is more readable. For what its worth I prefer the second one.

Answer 2

Neither creating the function, nor looking it up are costly operations in JavaScript, so if you have an "array" with a decent # of elements in it, the difference between either method will be negligible.

Answer 3

The second one is more efficient. This

  chop: function() 
  { map( 
    function(element) 
    {
      ... chop off last character ... 
    } 
  )}

will create a new function object on each call to chop() with the respective runtime and memory overhead. As there won't be any lingering references to the new object, it can be immediately gargage collected, but it's still bad practice to create more objects than necessary.

I'd suggest the following pattern:

MyObject.prototype = (function() {

    function map(fn) { ... }

    function chopElement(element) { ... }

    function chop() {
     this.map(chopElement);
    }

    return {
     map : map,
     chop : chop
    };

})();

Answer 4

Trading a function closure, for another function closure doesn't lead to a more efficient code. The most memory efficient one would be one that does not use closures at all.

__proto__ = {
  map: function(){},
  _chop: function(str){
    return str.slice( str.length, -1 );
  },
  chop: function(arr){ 
    this.map(this._chop, arr);
  }
}

This question rates very high on google for "closure memory usage", I don't think it qualifies. This is a problem that is difficult to diagnose though.

The answer here is more an example of hiding functionality within a closure, but it adds the cost of maintaining that memory space to store those private variables.