Few JavaScript Patterns

Just to be clear and once again, JavaScript can emulate:

• classes
• public and public static methods or properties
• private and private static methods or properties
• public and private constants
• protected methods
• ... you name it ...

// duck typing ( maybe all you need )
var me = {name: "WebReflection"};

// basic class
function Person() {}
Person.prototype.getName = function () {
    return this.name;
};
Person.prototype.setName = function (name) {
    this.name = name;
};

// module pattern + private properties / methods
function Person(_name) {
    function _getName() {
        return _name;
    }
    return {
        getName: function () {
            // redundant, example only
            return _getName();
        },
        setName: function (name) {
            _name = name;
        }
    };
}

// private shared methods via this
var Person = (function () {
    function Person() {}
    function _getName () {
        return this.name;
    }
    function _setName (name) {
        this.name = name;
    }
    Person.prototype.getName = function () {
        return _getName.call(this);
    };
    Person.prototype.setName = function (name) {
        _setName.call(this, name);
    };
    return Person;
}());

// private shared method Python style
var Person = (function () {
    function Person() {}
    function _getName (self) {
        return self.name;
    }
    function _setName (self, name) {
        self.name = name;
    }
    Person.prototype.getName = function () {
        return _getName(this);
    };
    Person.prototype.setName = function (name) {
        _setName(this, name);
    };
    return Person;
}());

// public static
function Person() {
    Person.TOTAL++;
}
Person.TOTAL = 0;

// private static / constant
var Person = (function () {
    var TOTAL = 0;
    return function Person() {
        TOTAL++;
    };
}());

// public constant
function Person() {}
Object.defineProperty(Person, "RACE", {
    writable: false,    // default
    configurable: false,// default
    enumerable: true,
    value: "HUMAN"
});

// public inherited constant
function Person() {}
Object.defineProperty(Person.prototype, "RACE", {
    writable: false,    // default
    configurable: false,// default
    enumerable: true,
    value: "HUMAN"
});

// protected method
function Person() {}
Person.prototype.getName = function () {
    return this instanceof Person ?
        this.name :
        throw "protected method violation"
    ; 
};
Person.prototype.setName = function (name) {
    this instanceof Person ?
        this.name = name :
        throw "protected method violation"
    ; 
};

// generic protected methods
Function.prototype.protectedVia = function (Class) {
    var method = this;
    Class || (Class = Object);
    return function () {
        if (this instanceof Class) {
            return method.apply(this, arguments);
        }
        throw "protected method violation on " + (
            Class.name || Class
        );
    };
};
function Person() {}
Person.prototype.getName = function () {
    return this.name;
}.protectedVia(Person);
Person.prototype.setName = function (name) {
    this.name = name
}.protectedVia(Person);

// private shared variables
function Person() {}
Person.prototype.getName = function () {
    return this.name;
};
(function (PersonPrototype) {
    var changes = 0;
    PersonPrototype.setName = function (name) {
        changes++;
        this.name = name;
    };
    PersonPrototype.howManyChangedName = function () {
        return changes;
    };
}(Person.prototype));

// getters / setters on public property
var person = Object.defineProperty({}, "name", {
    get: function () {
        return this._name;
    },
    set: function (_name) {
        this._name = _name;
    }
});

// getters setters on public property via prototype
function Person() {}
Object.defineProperty(Person.prototype, "name", {
    get: function () {
        return this._name;
    },
    set: function (_name) {
        this._name = _name;
    }
});

// getters / setters on private property
var person = Object.defineProperty({}, "name", (function () {
    var _name;
    return {
        get: function () {
            return _name;
        },
        set: function (name) {
            _name = name;
        }
    };
}()));

// singleton
var me = {name: "WebReflection"};

// singleton via anonymous __proto__
// plus private properties
var me = new function () {
    var _name;
    this.getName = function () {
        return _name;
    };
    this.setName = function (name) {
        _name = name;
    };
};

// generic singleton cross browser
Function.prototype.singleton = (function () {
    function anonymous(){};
    function create(Class, args) {
        anonymous.prototype = Class.prototype;
        Class.apply(
            Class.__singleton__ = new anonymous,
            args
        );
        return Class.__singleton__;
    }
    return function singleton() {
        return this.__singleton__ || create(this, arguments);
    };
}());

// generic singleton ES5
Function.prototype.singleton = (function () {
    function create(Class, args) {
        Class.apply(
            Class.__singleton__ = Object.create(
                Class.prototype
            ), args
        );
        return Class.__singleton__;
    }
    return function singleton() {
        returh this.__singleton__ || create(this, arguments);
    };
}());

// per function private singleton
var Person = (function () {
    var instance;
    return function Person () {
        return instance || (instance = this);
        // or ... ot be more than sure ...
        return instance || (
            (instance = true) && // avoid infinite recursion
            (instance = new Person)
        );
    };
}());

// generic factory
Function.prototype.factory = (function () {
    function anonymous() {};
    return function factory() {
        anonymous.prototype = this.prototype;
        var instance = new anonymous;
        this.apply(instance, arguments);
        return instance;
    };
}());

// generic factory ES5 + ruby style
Function.prototype.new = function factory() {
    var instance = Object.create(this.prototype);
    this.apply(instance, arguments);
    return instance;
};