eoo

Base library for OO style programming, supports both browser and node

Usage

inherits Class

Top Class is the Class

// var Class = require('oo')require(['oo'],function(Class){// a base classvarSuper=Class({// constructor will be called on instantiationconstructor: function(){},// members that will be added to the prototypesay: function(content){console.log(content)}});// inherits the SupervarSub=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 codethis.prop=prop;},say: function(content){this.$super(arguments);console.log(this.prop)}});varsup=newSuper();sup.say('hi');varsub=newSub('sub');sub.say('fuck!');});

inherits Object

This equals Object.create method.

Class.static(obj);

attribute

Class#constructor

if config a constructor, and it is a function, it will be called on instantiation

Class#$super

$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!

Class#$self

this property references the instance's Class:

varBase=Class();varinstance=newBase();instance.$self===Base// true

Class.$superClass

references the super class:

varSuper=Class();varSub=Class(Super);Sub.$superClass===Super// true

Class.create

alias of Class

Class.static

creates a new object with the specified prototype object and properties. Just equals Object.create method.

Class.defineAccessor

quickly generator the accessor for the object;

Class.defineAccessor(obj,'name');typeofobj.setName==='function';// truetypeofobj.getName==='function';// true

Class.defineMembers

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;

varSuper=Class({method: function(){console.log('super method!');}});varSub=Class(Super);oo.defineMembers(Sub,{method: function(){this.$super(arguments);console.log('sub method');}});varinstance=newSub();instance.method();// 'super method'; 'sub method';

Class.createPrivate

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 functionprivatePrototypeMethod: function(){returnthis.getPrivateProp();}});varMyClass=Class({constructor: function(){$private(this).privateProp='privateProp';},getPrivateProp: function(){return$private(this).privateProp;},callPrivateMethod: function(){$private(this).privatePrototypeMethod.call(this);}});varmy=newMyClass();alert(my.getPrivateProp());// 'privateProp'alert(my.callPrivateMethod());// 'privateProp'

Class.defineProtect

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');}});varSuper=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();}});varSub=Class(Super,{invoke: function(){$subProtect(this).method();$subProtect(this).protectMethod();}});Class.defineProtect(Sub,$subProtect);vars=newSub();// 'call method'// 'call Sub protectMethod'// 'call Super protectMethod's.invoke();