ctor

ctor
====

A simple and familiar prototypal system.

``
var Ctor = require('ctor');

var Person = Ctor.extend({
constructor: function Person(name, nickname) {
this.name = name;
this.nickname = nickname;
}
, sayHello: function() {
return "Hey, I'm " this.name + '. 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 " + this.name + '. 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".