sirmixalot
v0.0.2
Published
Utilities for making it easier to use some alternatives to inheritance
Downloads
8
Readme
Sir Mix-a-Lot
Using composition over inheritance has been proposed many times and has been shown to result in code which is much more flexible to changing requirements. This library aims to provide some utilities to make alternatives to inheritance easier than they previously were. For a nice overview of the benefits, check out this blog post.
Inheritance
For many people, inheritance is the default tool to use when designing complex systems. Javascript makes inheritance pretty easy now to the point where you can generally even get away with not knowing that it uses prototypal inheritance rather than classical inheritance. Here's an example of what inheritance looks like in ES6:
class Vehicle {
go() {
console.log('vroom');
}
}
class Car extends Vehicle {
}
const car = new Car();
car.go();
// > vroom
Unfortunately, inheritance has a few issues which mean it may not be the best design decision. Firstly, multiple inheritance is not supported in many languages, including Javascript. Secondly, inheritance enforces that you gain all of the attributes of the parent class (since Javascript doesn't have real access modifiers like private/protected/public) when only a few may be needed. Together, these issues make it hard to structure your classes to optimise reuse and readability.
Mixins
Javascript allows you to dynamically create classes using class expressions. This can be used to create mixins, which still use inheritance but allow you to get around some of the issues found in normal inheritance. A mixin in Javascript might look like this:
function Mixin(superclass = class {}) {
return class extends superclass {
go() {
console.log('vroom');
}
}
}
class Car extends Mixin() {
}
const car = new Car();
car.go();
// > vroom
This library provides the mix
function which can be used with mixins defined
as subclass factories to create a new inheritance chain. The mix function is
called like this:
class SubClass extends mix([Mixin1, Mixin2, Mixin3], SuperClass) {
}
And creates a prototype chain that looks like this:
SubClass
-> Mixin1
-> Mixin2
-> Mixin3
-> SuperClass
Delegation
Delegation is a tool that makes composition easier to use because it removes a lot of the boilerplate that would otherwise need to be written. Delegation creates new methods which are proxies to methods on an object held by the delegating class. An example of delegation looks like this:
class Vehicle {
go() {
console.log('vroom');
}
}
class Car {
this.vehicle = new Vehicle();
}
delegate(Car, 'vehicle', ['go']);
const car = new Car();
car.go();
// > vroom
In this case, the Car
class holds a reference to a vehicle instance, and the
delegate
function creates a new go
method on the car class which calls
this.vehicle.go()
. Delegation allows you to avoid the use of inheritance
entirely, giving much more flexibility.