Skip to content
Base library for OO style programming
JavaScript HTML
Branch: develop
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
demo
src
test
.gitignore
.travis.yml
LICENSE
README.md
bower.json
package.json

README.md

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 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!');
});

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:

var Base = Class();
var instance = new Base();
instance.$self === Base // true

Class.$superClass

references the super class:

var Super = Class();
var Sub = 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');
typeof obj.setName === 'function'; // true
typeof obj.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;

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';

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 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'

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');
    }
    });

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();
You can’t perform that action at this time.