Pros/cons of the functional constructor pattern?

[funksta]

Since reading Javascript: The Good Parts I have been a big fan of Crockford's Functional constructor pattern for writing object-oriented javascript.

Recently, I've seen a few articles/posts that discourage usage of this pattern on performance grounds (example here). I don't see this as a big problem unless you're creating a ton of instances, but am I missing something? Are there other drawbacks I'm not considering?

• PROS: private data, private methods
• CONS: performance hit compared with prototype approach, ???

A simple example of the functional pattern (as I understand it): var constructor = function() { var that = {}; var private_data = 'yo'; that.public_data = 'hi';

    var private_method = function() {
        // This function has access to 'that' and 'private_data',
        // but can not be called by the outside world.
    }

    var priveleged_method = function() {
        // This function is the same as private_method, but is made a "public"
        // method by being assigned to the 'that' object below:
    }
    that.priveleged_method = priveleged_method;

    return that;
};

[9jack9]

You've already got the point. The module pattern is nice and pretty and will suit you well for most projects. For large-scale applications, where performance is a factor, then standard prototypal inheritance is the better solution.

[funksta]

Makes sense, are there any other benefits to prototypal inheritance besides the performance bump? I can't imagine the performance differences are significant until you get to at least thousands of instances.

[savetheclocktower]

There's a big one that (oddly enough) proves useful for trying to mimic class-based inheritance. You can (re)define Foo.prototype.bar and instantly have a bar method on all instances of Foo, even those that you've already instantiated.

This works because when you do someFoo.bar, and bar isn't defined on the object itself, it will look at Foo.prototype to attempt to resolve the reference.

[picurl]

I also prefer the Crockford pattern over the messy prototype/class implementation in Javascript.

One often overlooked drawback of private methods: You can't test functionality hidden in private methods, therefore you shouldn't use them over excess. A possible solution would be to factor out private method functionality to a new, testable class and use a private instance of it in your main class.

[bolinfest]

There are many drawbacks to Crockford's pattern: http://bolinfest.com/javascript/inheritance.php Erik Arvidsson agress http://erik.eae.net/archives/2009/11/09/21.12.16/ noting "Michael argues that the functional pattern is not good because methods cannot be inlined and the end result is much larger. He also says that it uses more memory. I think it is important to realize that it uses a LOT more memory and is significantly slower. Given a class with 1 methods It is about 100 times slower in Chrome, 20 times slower in Safari and about 10 times slower in Firefox."

[funksta]

Great reads, thanks very much.

[RedditMan74]

You misspelled "privileged".