wheels-class

Simple and powerful classical inheritance for JavaScript. Fully compatible with CommonJS / Node, AMD and standard browser script tag include

npm install wheels-class
8 downloads in the last month

Wheels Class

Simple and powerful classical inheritance for JavaScript. Super lightweight, with no dependencies and fully compatible with CommonJS / npm, AMD and standard browser script tag include.

Install

wheels-class can be installed with CommonJS / npm, AMD or standard browser script tag:

npm

npm install wheels-class

AMD / RequireJS

require(["wheels-class"], function( Class ) {
  var MyClass = new Class();
});

Traditional browser script tag

<script type="text/javascript" src="path/to/wheels-class.js"></script>
<script type="text/javascript">
  var MyClass = new Wheels.Class();
</script>

Usage

Class definition

Pass an object to the constructor to create a class and add the object's properties to the class prototype property:

var Foo = new Class({
  greet: function() {
    return "Hello :)";
  }
});

var foo = new Foo();
foo.greet(); // => "Hello :)"

Alternatively, you can pass a function to the constructor, and it will be executed in the scope of the class. That means that, whithin the function, this is the class itself. Also, the function will receive the prototype property of the class as the first argument:

var Foo = new Class(function( proto ) {

  // `this` is the class, here Foo
  this.classMethod = function() {
    return "I am a class method";
  }

  // first argument is the class `prototype` property (here Foo.prototype)
  proto.instanceMethod = function() {
    return "Hello :)";
  }

});

var foo = new Foo();

Foo.classMethod();    // => "I am a class method"
foo.instanceMethod(); // => "Hello :)"

Class inheritance

The subclass method creates a subclass and accepts the same arguments as the constructor:

var Animal = new Class({
  eat: function() {
    return "Yum :)";
  }
});

var Cat = Animal.subclass({
  meow: function() {
    return "Meow!";
  }
});

var nyan = new Cat();
nyan.eat();  // => "Yum :)"
nyan.meow(); // => "Meow!"

// The subclass also stores a reference to the superclass
Cat._superclass === Animal // => true

// And the instance stores a reference to the parent prototype
nyan._parent === Animal.prototype // => true

Include, augment and reopen

The include method accepts one or more objects and copies their properties to the class' prototype property:

var Duck = new Class();

Duck.include({
  quack: function() {
    return "Quack!";
  }
});

var donald = new Duck();
donald.quack(); // => "Quack!"

The augment method accepts one or more objects and copies their properties to the class:

var Foo = new Class();

Foo.augment({
  classMethod: function() {
    return "I am a class method!";
  }
});

Foo.classMethod(); // => "I am a class method!"

The reopen method accepts the same arguments as the Class constructor: if you pass an object, its properties get added to the class prototype, if you pass a function it is executed in the scope of the class, passing the prototype as the first argument.

var Human = new Class(),
    john = new Human();

// Passing an object
Human.reopen({
  sing: function() {
    return "Goo goo goo joob!";
  }
});

john.sing(); // => "Goo goo goo joob!"

// Passing a function
Human.reopen(function( proto ) {

  // `this` is the class, here Human
  this.cogito = function() {
    return "ergo sum.";
  };

  // proto here is Human.prototype
  proto.eat = function() {
    return "Yum!"
  };

});

Human.cogito(); // => "ergo sum."
john.eat();     // => "Yum!"
npm loves you