NetBen Ramblings about JavaScript and frontend development.

So I reinvented prototype.js…

** EDIT, Library name is now JSoo, leaving this post intact to remind me of my stupid name choice for a library **

No, I am not talking about prototype.js from prototypejs.org I've actually created a prototypical Prototype Multiple Inheritance System and Module Pattern decorator library. Considering what the library does, I found Prototype was the best name for it and my appologies in advance to the prototypejs crew for naming it likewise. I also have to add, this is merely a working draft version and imo. good enough to release, namespace issues will be a later concern (though I am using a special namespace pattern for plug and play action )

As a reaction to the Javascript Inheritance Performance post on Ajaxian, I found myself thinking; "Why is everyone trying to superimpose Classical OO on Prototypical OO" and "There should be a better way according to what Douglas Crockford tries to teach us through his articles and book". So I got to work and Prototype + Prototype.Module is my idea on how to handle inheritance in a nice and orderly way.

Other inheritance systems solve it function.prototype = {} >here<.
This inheritance system solves it >here< function.prototype = {}

A complete description of Prototype & Prototype.Module can be found here. *EDIT LINK CHANGED*

The library can be downloaded to play around with here. *EDIT LINK CHANGED*

A quick example to entice and show what the library does.

Prototype example:

The Prototype function basically leaves the functions alone and only handles property hashes, so we can assign them to functions AFTER they're properly defined. It also supports multiple inheritance the prototypical way and allows back references to donor property hashes.

    Prototype("MammaCat", {
        talk: function() {
            return this.name + " says: miauw";
        }
    });

    var MammaCat = function(name) {
        this.name = name;
    }
    MammaCat.prototype = Prototype("MammaCat");

    var Pookie = new MammaCat("Pookie");
    alert(Pookie.talk()) //==> Pookie says: miauw

    Prototype("Kitten", {
        talk: function() {
            return this.name + " says: meep";
        },
        myMommaSays: function() {
            return "my momma " + this["::MammaCat"].talk.apply(Pookie);
        }
    }, "MammaCat"); // <-- Inherit methods from Cat.

    var Kitten = function(name) {
        this.name = name;
    }
    Kitten.prototype = Prototype("Kitten");

    var Bella = new Kitten("Bella");
    alert(Bella.talk()) //==> Bella says: meep
    alert(Bella.myMommaSays()) //==> Pookie says: miauw

Prototype.Module example:

Prototype.Module provides a neat way to organise Module Patterns as well as allow the sharing of private variables over multiple Module Patterns through closure techniques.

    Prototype.Module("combat", function(cache) {
        cache.baseDamage = 10;
        return {
            rake: function() {
                alert(this.name + " rakes for " + cache.baseDamage + " damage");
            }
        }
    });

    Prototype.Module("specialAttacks", function(cache) {
        return {
            claw: function() {
                // yes, we reference a value set in another module pattern through the cache argument!
                alert(this.name + " claws" + (cache.baseDamage + 10) + " damage");
            }
        }
    });

    // the cache argument in the module patterns gets shared as long as you assign the
    // modules in a single call.
    Prototype.Module.attach(Pookie, "combat", "specialAttacks");
    Pookie.rake(); //==> Pookie rakes for 10 damage
    Pookie.claw(); //==> Pookie claws for 20 damage

The code is at version 0.0.1 and is basically a first draft to show how inheritance can be solved the prototypical way. I do understand people want to make JavaScript look and behave more like Java, but it's simply not a classical OO language. Use and embrace the prototypical way of scripting!

I am sure people can find errors, performance issues and have better ideas or suggestions, feel free to post them and I will incorporate it, proper credits will be given

And if someone knows of a better name then Prototype (to avoid possible conflict with the good and nice lads at prototypejs.org), then I am very much open to suggestions.