How to implement inheritance in JS Revealing prototype pattern?

Question

How do I inherit/extend classes that are using the Revealing Prototype pattern? And is there a way to make the private variables and functions protected?

Example base object:

myNameSpace.Person = function() {

    this.name= "";
    this.id = 0;

};

myNameSpace.Person.prototype = function(){
    var foo = function(){
        //sample private function
    };
    var loadFromJSON = function (p_jsonObject) {
       ...
    };
    var toJSON = function () {
       ...
    };
    var clone = function (p_other) {
       ...
    };

    return {
        loadFromJSON : loadFromJSON,
        toJSON: toJSON,
        clone: clone
    };
}();

Rodriguez

Answer 1

There are no protected variables/properties in JavaScript. Though, you can reuse "private" variables when you declare the inheriting classes in the same scope, which seems possible in your case when the private variables are only "hidden utilities" of your prototype.

MyNamespace.Person = function Person(params) {
    // private variables and functions, individual for each Person instance
    var anything, id;
    function execute_something() {}

    // public properties:
    this.name = "";
    this.getId = function getId(){
        // called a "privileged function", because it has access to private variables
    }
}
MyNamespace.American = function(params) {
    MyNamespace.Person.call(this, params); // inherit name and getId()
}

(function() { // new scope for
    // hidden utility functions and other private things
    function foo() { }
    function helpJSON() { }
    function fromJSON() { }
    var bar;

    (function(personProto) { // new scope for prototype module (not explicitly needed)
        // "private" /static/ variables (and functions, if you want them private)
        var personCount = 0;

        personProto.clone = function clone() {
            return this.constructor(myself); // or something
        };
        personProto.toJSON = function toJSON() {
            // use of helpJSON()
        };
        personProto.fromJSON = fromJSON; // direct use
    })(MyNamespace.Person.prototype);

    (function(amiProto) {
        // just the same as above, if needed
        amiProto.special = function() {
            // use foo() and co
        };
    })( MyNamespace.American.prototype = Object.create(MyNamespace.Person.prototype) );
})();

This is the JavaScript way of inheritance, which means American's prototype inherits the clone(), toJSON() and fromJSON() functions automagically from the Person's prototype. Of course overwritable. And the feature is

new MyNamespace.American() instanceof MyNamespace.Person; // true

Of course, if you don't need that, and want use the more module-like way, you could reuse the utility functions, i.e. just copy them:

(function() {
    // hidden utility functions and other private things
    var bar;
    var personCount;
    function foo() { }
    function helpJSON() { }
    function fromJSON() { }
    function clone() {
        return this.constructor(myself); // or something
    }
    function toJSON() { }

    (function(personProto) { // new scope, not really needed
        // private variables are useless in here
        personProto.clone = clone;
        personProto.toJSON = toJSON;
        personProto.fromJSON = fromJSON;
    })(MyNamespace.Person.prototype);

    (function(amiProto) { // new scope, not really needed
        // copied from personProto
        amiProto.clone = clone;
        amiProto.toJSON = toJSON;
        amiProto.fromJSON = fromJSON;
        // and now the differences
        amiProto.special = function() {
            // use foo() and co
        };
    })(MyNamespace.American.prototype);
})();

Battement

If you want to find out more on inheritance and prototype there is a great read in here: killdream.github.com/blog/2011/10/understanding-javascript-oop/… I think you can go to point 3 where inheritance begins. – Klansman

@Programmer_D: It's moved to robotlolita.me/2011/10/09/understanding-javascript-oop.html. And of course you can also view the old version – Battement

Using function Person(params) pollutes the namespace. – Stretto

@AndroidDev Yes of course, you need to do new Person(params). Also, use strict mode. – Battement