I use it all the time as it gives a clear definition of what is meant to be where. If you want to have many objects of the same class or extension etc use a different pattern.

If you want to declare private members of prototyped objects just prefix them with _ it’s not very hard to follow.

2Pence.

After having written a dozen of JavaScript library files and coming up with my own pattern for handling semi-private data, all the while making use of Prototype’s OO mechanism, plus failing to use and like the YUI library in its 3.0 development version…

I would rather avoid any extra headache at this point.

Microsoft with Novell and Mono just gave me another one a few minutes ago. Novell’s Miguel de Izaca announced Moonlight 1.9 beta and I installed it and went where I could find Silverlight demos and I could not manage to see any Silverlight content using Moonlight after some three tries. Just uninstalled Moonlight thinking “thank goodness JavaScript can help me with staying out of too much trouble”.

var m = new Module("pattern");
m.ask();
// asked for pattern 1 times


I find that this singleton better is far easier to use.

var MySingleton = new (function() {
this.public = “i’m public”;
var private = “i’m private”;
});

Much simpler and cleaner. I found this on http://nortools.blogspot.com/2008/06/my-javascript-patterns.html

Cheers
Adam

This may not matter for small apps, but for large Javascript applications, something like GMail or Spreadsheets, it makes a large difference. This is one reason why GWT is so effective at creating packed code.

As far as inheriting private properties and methods, one, if you have a method or property that you want to inherit, perhaps you want an “intenal” propety or method instead, as truly private members are only really scoped to the class and all instances of that actual class, and not children. In order to do this you need getter methods for all the internal properties or methods you wish to inherit, and you need to use private variables in the inheriting class to set them to the prototype’s inherited properties. For Example:

var ParentClass = function(){
var inheritedMember = ‘foo’;//inherited member of a child class.
var privateMember =’bar’; //private member that will not be inherited
this.getInheritedMember = function(){return inheritedMember;};
};
ParentClass.prototype = (function(){ return new Object();})();
var ChildClass = function(){
var inheritedMember = ChildClass.prototype.getInheritedMember();//inherits the parent member directly
this.useInheritedMember = function(){
alert(inheritedMember);
};
}
ChildClass.prototype = (function(){return new ParentClass();})();

var test = new ChildClass();
test.useInheritedMember();

Is it easy? No. You have to remember the members you want to inherit for each class. If you override an inherited member, you also have to override the getter method for that member. If you are inheriting a large number of internal properties, the inherited members and getters can take up a lot of space. Also, since the getters are public and JavaScript is a dynamic language, they can be overwritten at runtime. But it is definitely doable, and keeps your internal methods and properties from being accessible outside the class structure.