js-class

Define classes in Javascript

Define Classes in Javascript

This is a simple module providing a simple Class function to simplify class definition in Javascript.

npm install js-class

With Node.js:

var Class = require('js-class');

In browser, just include js-class.min.js

To rebuild js-class.min.js, type:

npm install
npm run-script build
Class(baseClass, prototype, options);
  • baseClass: baseClass type, optional, default is Object;
  • prototype: the prototype for new class;
  • options: other options like implements and statics, see details below.

The newly defined class.

A simple and quick sample:

var Class = require('evo-elements').Class;
 
var MyClass = Class({
  constructorfunction (value) {
    // this is the constructor 
    this._value = value;
  },
    
  printfunction () {
    console.log(this._value);
  },
  
  // getter/setter is supported 
  get value () {
    return this._value;
  },
  
  set value (value) {
    if (!isFinite(value)) {
      throw new Error('Bad Value');
    }
    this._value = value;
  }
});
 
var myObject = new MyClass(1);
myObject.print(); // get 1 
myObject.value = myObject.value + 100;
myObject.print(); // get 101 

A simple inheritance sample:

var BaseClass = Class({
  constructorfunction (value) {
    this.value = value;
  },
  
  printfunction () {
    console.log('BaseClass: %d', this.value);
  }
});
 
var SubClass = Class(BaseClass, {
  constructorfunction (val1val2) {
    BaseClass.prototype.constructor.call(this, val1 + val2);
  },
  
  printfunction () {
    console.log('SubClass');
    BaseClass.prototype.print.call(this);
  }
});
 
var myObject = new SubClass(1, 2);
myObject instanceof SubClass;   // true 
myObject instanceof BaseClass;  // true 
myObject.print();
// get 
// SubClass 
// BaseClass: 3 

Multiple inheritance with implements

var ActiveBuffer = Class(Buffer, {
  // override Clearable 
  clearfunction () {
    // TODO I hate to be cleared 
    this.emit('cleared');
  }
}, {
  implements: [EventEmitter, Clearable]
});
 
var buffer = new ActiveBuffer().on('cleared', function () { console.log('CLEARED'); });
buffer.clear();
 
buffer instanceof Buffer; // true 
buffer instanceof EventEmitter; // false 
buffer instanceof Clearable;  // false 

Static members

var Singleton = Class({
  constructorfunction () {
    // ... 
  },
  
  workfunction () {
    // ... 
  }
}, {
  statics: {
    get instance () {
      if (!Singleton._instance) {
        Singleton._instance = new Singleton();
      }
      return Singleton._instance;
    }
  }
});
 
Singleton.instance.work();

MIT/X11 License