What is the recommended approach for helper functions in JavaScript?

Question

What is the recommended approach for helper functions? I would like to choose one technique, and run with it to create my new "class".

Here are the design options I have pondered:

Option 1: Helper function in outer scope, invoke with context of instance

function createPane (pane) {
 // logic to create pane
 var proto = Object.create(this.paneList);
 $.extend(paneProto, pane);
 return paneProto;
}
Panes.prototype.initialize = function (panes) {
 var _this = this;
 _.each(panes, function () {
 _this.panes.push(createPane.call(_this, this));
 });
}

• Pros: Simple syntax. createPane is not published on the instance.
• Cons: createPane is accessible in other scopes.

Option 2: Helper function in closure, invoke with context of instance

Panes.prototype.initialize = (function () {
 function createPane (pane) {
 // same logic as last createPane
 }
 return function (panes) {
 // same logic as before - calls createPane
 }
})();

• Pros: createPane is not published on the instance.
• Cons: Lower readability and testability; Testing of this helper must occur in the scope of initialize.

Option 3: Prepend _ to name to indicate a private method

Panes.prototype._createPane = function (pane) {
 // same logic as last createPane
}
Panes.prototype.initialize = function (panes) {
 // same logic as last, except calls this._createPane
}

• Pros: Implicit context of _createPane is the instance. Testability from the outside.
• Cons: Exposing helper function on the instance.

Option 4: Helper functions as arguments

Panes.prototype.initialize = (function (createPane) {
 return function (panes) {
 // same logic as before - calls createPane
 }
})(function createPane () {
 // same logic as last createPane
});

• Pros: createPane is not published on the instance. Helper functions lack access to each other.
• Cons: Lower readability and testability; Testing of this helper must occur in the scope of initialize.

• gnat: see: Are there any OO-principles that are practically applicable for Javascript?

Answer 1

First JavaScript doesn't have Classes.

Second, your third option seems more rational to me, but it highly depends to your requirements as well. Also you should not be much worried about exposing the helper function. The pros of the solution totally justifies the compromise to me.

Third, your time as a developer is valuable; Don't make trivial tasks hard to implement, time consuming and more pron to human-errors. Simplicity of source code is a great feature itself.

• TaylorMac: Mahdi thank you. I am a long time JavaScript user and yes, that's the reason why I wrote "class" in quotes. Although, terminology is misleading, and many professional organizations refer to JavaScript's constructor functions as classes. developer.mozilla.org/en-US/docs/Web/JavaScript/…
• TaylorMac: And thank you for the suggestion on simplicity. My question is more about scope than anything, accessibility. Strict vs. Loose.
• Mahdi: @TaylorMac You're very welcome, hope it helps.
• Ala Eddine Menai: @Mahdi, currenlty Javscript has classes.

Answer 2

Statics belong on the Function IMO, in your case you have a private static, so ...

Panes._createPane=function(pane){}