Javascript Constructors and Prototypes

> In what other language are people still having holy wars over how to separate statements?

Probably most of the languages in popular use. It's just that the fight is usually directed towards another language.

JS happens to be one of the minority where the standard allows some flexibility and debate about usage.

> mysterious constructs like prototype, new, and apply

They're well-defined, so they're not particularly mysterious if you take the time.

> Are we seriously incapable of doing better?

Really depends on how much effort you're willing to invest in learning JavaScript, instead of trying to write the code you're used to from $OTHER_OO_LANGUAGE. Everyone unwilling to do that is probably never going to be capable of doing better.

This isn't to say there's anything wrong with finding another familiar set of abstractions friendly or personally productive, but personally, I find greenfield JS is pretty fun, flexible, and capable.

Then again, I think the same thing about Perl (which everyone knows is one of the worst languages ever), so YMMV.

"Someone pointed out though, that you can prevent this polluting of the namespace (those are just big words for creating global variables) by using this trick:

     function Person(name){
        if (!(this instanceof Person))
            return new Person(name)
        this.name = name
     }"

This is useful for situations where you might want to be able to create anonymous objects and call a series of methods on them, which can be a nice API as any user of jQuery knows.

It's also an arguably cleaner way of achieving the constructor+apply thing he does later -- no global modification of the Function prototype.

A lot of the time, though, I'll just consider this my default "class" definition:

    function Person (args) { this.init(args); }

If you want to be warned (or want others to be warned) when Person is called w/o new, this will do it (unless someone has defined init on the global namespace, so avoid that).

This also makes it easier to hand around the method that does the actual construction, which is helpful for cases like constructor + apply:

    var p = new Person;
    p.init.apply(p,args);

(again, without global modification of the Function prototype) or for cases where you want to refer to "superclass" methods down an inheritance hierarchy.

Maybe mysterious wasn't the best choice of word, but my point is that it's quite possible for something to be well-defined and yet poorly usable.

I long since gave up on trying to write the code I'm used to in other OO languages in JS. When I'm in JS Land, I put a lot of effort into using best practices. I just find it frustrating that so many of those best practices do not at all seem to adhere to any sort of principle of least surprise. And I wouldn't say that my problem is being too tightly bound to a particular OO paradigm; I've had great fun programming in functional styles and Prolog.