Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
53 lines (41 sloc) 1.72 KB


A simple and familiar prototypal system.

var Ctor = require('ctor');

var Person = Ctor.extend({
  constructor: function Person(name, nickname) { = name;
    this.nickname = nickname;
  , sayHello: function() {
    return "Hey, I'm " + + '. But you can call me ' + this.nickname; 

var p = Person.create('Marco', 'polotek');

console.log(p.sayHello()); // Hey, I'm Marco. But you can call me polotek

var Employee = Person.extend({
  constructor: function Employee(name, nickname, job) {
    // The person constructor has already been called
    this.job = job;
  , sayHello: function() {
    // No concept of "super". If you want a super call, be explicit
    return "Hello, my name is " + + '. I work at ' + this.job;

var e = Employee.create('Marco', 'polotek', 'Acme Novelties');

console.log(e.sayHello()); // 'Hello, my name is Marco. I work at Acme Novelties'

// (p instanceof Person) === true
// p.sayHello === Person.prototype.sayHello
// (e instanceof Employee) === true
// (e instanceof Person) === true
// (e.__proto__ instanceof Person) === true

ctor is a really simple prototypal object system that codefies a few simple constructs that I like.

  • Don't use new. Think of create as your object factory. This follows nicely from Object.create.
  • There is a constructor for initializing your objects. create calls this on every object.
  • Instead of "inheritance", there is simple extension. extend creates a new object factory with the following behavior
    • Proper prototype chain is set up.
    • The extended parent constructor will always be called implicitly. Initialization integrity is preserved.
    • No other fanciness. No "super".