I mean code like this:
function MyObject(x, y, z) {
this.init(x, y, z);
}
MyObject.prototype = {
constructor: MyObject,
init: function(x, y, z) {
// actually use x, y, z
},
other methods
};
Why not just not have an init method and do all the initialization in the constructor?
None. Really, none. Your constructor function does not do anything more than init. This is more or less an antipattern.
The advantage of a method that initializes the object would be that it could be called multiple times (on the same object), for use in object pooling or if just to reset it. However, every well-engineered JS object does have that method already: it's called .constructor(). It's the constructor function, by default available on its own prototype, and usually put on it explicitly if necessary (as was done in your example).
This means having an extra init method is rather useless, typically less performant and more verbose. Except maybe that you use this verbosity to emphasize (by name, and style of declaration) the use of it as a method, and possibly to ease a planned refactoring so that the actual constructor would do more than the init method (e.g. create constant fields). I'd avoid doing this prematurely, though, yagni.
In javascript, there is unfortunately no clean way to pass arguments up the constructor chain because constructors inherit from objects, not other constructors. For example consider the following:
function Person (name) {
this.name = name;
}
function Accountant () {}
Accountant.prototype = new Person('');
Now, if you want to create an Accountant there's no clean way to give him a name:
var x = new Accountant();
Of course, in this simple example you can simply set his name manually after creating him:
x.name = 'Andy';
But real world code may not always be as easily worked-around. Some object keep state in closures which means you'll have no way to pass the argument back to the parent's constructor because you've created the parent object when defining the child object's prototype.
One work-around is of course to not use inheritance at all but use decorator functions as if they were constructors:
function new_person (name) {
var self = {};
self.name = name;
return self;
}
function new_accountant (name) {
var self = new_person(name);
return self;
}
This design pattern is often called parasitic inheritance. Notice that in this design pattern we don't use the keyword new.
Another work-around, if you still want to use proper inheritance, is for objects to have an init function that can be called by any constructor that wants to inherit it:
function Person (name) {
this.init(name);
}
Person.prototype.init = function (name) {
this.name = name;
}
function Accountant (name) {
this.init(name);
}
Accountant.prototype = new Person('');
There are other, more fancy work-arounds of course. This being javascript, you're only limited by your creativity. But for prototype inheritance the init function looks like the simplest work-around requiring minimal code without needing additional libraries or a new version of the language.
