Usage of initialize() vs. setup() in Mootools

Mootools classes have an initialize() method that's called when a new object is instantiated.

It seems that setup() is a commonly used method as well.

Most classes I've observed call this.setup() from initialize() and nowhere else, which has left me wondering:

What's the purpose of set开发者_开发技巧up()? Why not just put the setup() code in initialize()? When does it make sense to use a setup() method?

as oskar says, there's no benefit to using that very name. If you wanted to, you could only use a single initialize function with a bunch of anonymous functions within and events but it does not make for very easy code to read, extend and maintain.

i tend to use methods like this.setupScene() and this.attachEvents() to abstract different actions. within these methods, i tend to loop through items and call smaller pseudo-private methods that do the singular dom manipulation required or element.addEvent, aka, this.elements.each(function(el) { this._attachEvent(el, "something"); }, this);

If you are sharing code with other users, there are certain conventions most mootools authors try to adhere to when releasing plugins or contributing to the core and more forks.

for example, if the class relates to an element or an array of elements, always set this.element = document.id(el); etc.

for reference on best practices: http://ryanflorence.com/11-tips-for-creating-great-mootools-plugins/ or even http://davidwalsh.name/mootools-class-tips

after a while, they start making perfect sense and will help you tremendously in your work.

There is no benefit whatsoever in using a setup/build/whatever function that is only called from the initialize function of a mootools Class.

I guess the distinction comes from languages where you don't have variable function arguments but rather overload function names with different sets of arguments. Like Java.

In Java this makes perfect sense. When you have multiple constructors that differ in the arguments they accept, then you handle the argument specific operations in your constructor and the common stuff, that every constructor needs to call in a method that is called by all constructors.

Personally I don't make this distinction in my mootools Classes, but rather only outsource functionality in its own function, if there is need to reuse the code from another function.

Don't get confused by setup functions, there is no hidden power to them.

setup is not a private MooTools method. It's not going to do anything until you create an actual method named this way.

There's one instance of this method in MooTools-more, and it's nothing beyond a simple keyword, just like createDefaults() or setInitialStuff() would be.

Keep in mind that MooTools classes are all about extending and reusing existing code. When you extend a class, you might want to change the initialization, but not the setup code. Of course you can run the parent initializer by using this.parent(), but that might introduce unwanted side-effects.

Take this (very simple) example (view live):

var Counter = new Class({
    initialize: function(i){
        this.i = i;
        this.setup();
    },

    setup: function(){
        new Element('p', {
            'text': this.i
        }).inject(document.body);
    }
});

var MultiplyCounter = new Class({
    Extends: Counter,

    initialize: function(i){
        this.i = i * 2;
        this.setup();
    }
});

new Counter(5);
new MultiplyCounter(5);

The extended class only changes the initialization of i, not the whole implementation of the class. For more complex classes, this creates faster (initialization is only run once) and cleaner (divide and conquer) code.