I some times create class like this
function class1(){
.....
class1.prototype.callme = function(){
alert("hai");
}
}
then I instantiate using (new class1()).callme();
and some times I use modular pattern
var class2 = (function(){
var privatemethod = function(){
....
}
var publicmethod = function(){
alert("am public");
}
return{
callme:publicmethod
}
})();
then I call class2.callme()
Whats the advantage and disadvantage, can some body please explain.
The first one is a constructor the second one is an object, so they're not the same. You might want to use one or other in different situations. In any case you usually declare the prototype outside the constructor and use this.property for public methods and variables. The second option is not reusable as a class, unless you use something like jQuery's extend or Underscore's _extend, which is the way I usually do it, it seems simpler without the prototype chain bloated code.
If you want to learn about the different Javascript patterns I would definitely recommend Learning JavaScript Design Patterns Its free/opensource and kept constantly updated.
For using Module pattern:
The freedom to have private functions which can only be consumed by our module. As they aren't exposed to the rest of the page (only our exported API is), they're considered truly private.
Given that functions are declared normally and are named, it can be easier to show call stacks in a debugger when we're attempting to discover what function(s) threw an exception.
As T.J Crowder has pointed out in the past, it also enables us to return different functions depending on the environment. In the past, I've seen developers use this to perform UA testing in order to provide a code-path in their module specific to IE, but we can easily opt for feature detection these days to achieve a similar goal.
prototypeinside the constructor function? In your first exampleclass1.prototype.callmeis overwritten every time you create a newclass1instance, which is kind of inefficient. And if you actually use(new class1()).callme()(i.e., that's not a simplification for this question) the whole class thing is kind of redundant.class1then that serves a different purpose to the second example but it's kind of hard to compare the two when you don't give a more realistic example.