Base library for OO style programming, supports both browser and node
Top Class is the Class
// var Class = require('oo') require(['oo'], function(Class) { // a base class var Super = Class({ // constructor will be called on instantiation constructor: function() { }, // members that will be added to the prototype say: function(content) { console.log(content) } }); // inherits the Super var Sub = Class(Super, { constructor: function(prop) { // $super method will call the Super Class's method with the same name, // in this, is `constructor` this.$super(arguments); // other code this.prop = prop; }, say: function(content) { this.$super(arguments); console.log(this.prop) } }); var sup = new Super(); sup.say('hi'); var sub = new Sub('sub'); sub.say('fuck!'); });
This equals Object.create method.
Class.static(obj);
if config a constructor, and it is a function, it will be called on instantiation
$super method will call the Super Class's method with the same name;
notice:
because $super internal implementation uses the arguments.caller, $super can not be used in strict mode!
this property references the instance's Class:
var Base = Class(); var instance = new Base(); instance.$self === Base // true
references the super class:
var Super = Class(); var Sub = Class(Super); Sub.$superClass === Super // true
alias of Class
creates a new object with the specified prototype object and properties.
Just equals Object.create method.
quickly generator the accessor for the object;
Class.defineAccessor(obj, 'name'); typeof obj.setName === 'function'; // true typeof obj.getName === 'function'; // true
Add properties to the function prototype so we can create a sub class first, and then add members to the sub class.
This will enable the function in the added members to use this.$super() feature;
var Super = Class({ method: function () { console.log('super method!'); } }); var Sub = Class(Super); oo.defineMembers(Sub, { method: function () { this.$super(arguments); console.log('sub method'); } }); var instance = new Sub(); instance.method(); // 'super method'; 'sub method';
create a private object whose prototype points the first param if has, and return a token function which accept an object as param, call the token function with an object, it will return the private part of the object, because the private part is just a object, you can do any operation on it. Do not expose the token function to the outside.
// MyClass.js // $private is a secret token function, and used in the module scope. var $private = Class.createPrivate({ // this method is on the prototype shared by all instance passed from the $private function privatePrototypeMethod: function () { return this.getPrivateProp(); } }); var MyClass = Class({ constructor: function () { $private(this).privateProp = 'privateProp'; }, getPrivateProp: function () { return $private(this).privateProp; }, callPrivateMethod: function () { $private(this).privatePrototypeMethod.call(this); } }); var my = new MyClass(); alert(my.getPrivateProp()); // 'privateProp' alert(my.callPrivateMethod()); // 'privateProp'
define a privateToken created by Class.createPrivate as the protectToken of the class
var $protect = Class.createPrivate({ protectMethod: function () { console.log('call Super protectMethod'); }, method: function () { console.log('call method'); } }); var Super = Class({ callProtectMethod: function () { return $protect(this).protectMethod(); }, $protect: $protect // config sugar, eoo will call Class.defineProtect internal; }); var $subProtect = Class.createPrivate({ protectMethod: function () { console.log('call Sub protectMethod'); // call super class protect method from $super keyword; $subProtect(this).$super.protectMethod(); } }); var Sub = Class(Super, { invoke: function () { $subProtect(this).method(); $subProtect(this).protectMethod(); } }); Class.defineProtect(Sub, $subProtect); var s = new Sub(); // 'call method' // 'call Sub protectMethod' // 'call Super protectMethod' s.invoke();