Improving EcmaScript5 OO with sugar
raynos.org
raynos.org
I wrote it because I didn't know about these other utilities / tools.
And being able to do
var obj = protoObj <| { ... properties ... }
We need an easy way to mixin/extend objects.
var obj = protoObj <| mixin({ ... properties ... }, mixinA);
object.create(obj);
obj.constructor();
I promote code like
var Cat = Object.make(Animal, {
constructor: function() {
Animal.constructor.apply(this, arguments);
...
},
walk: function() {
Animal.walk.apply(this, arguments);
...
}
});
- Animal.walk.apply(this, arguments);
- this.super.apply(this, arguments);
- this.super.walk.apply(this, arguments);
Using super doesn't fix verbosity, it only fixes hard coupling of Child class name to Super class name.
For the complexities, edge cases and performance penalties a super implementation gives, it's simply not worth fixing this hard coupling.
If you know of a super implementation that _just works_ please [Leave an answer on StackOverflow](http://stackoverflow.com/questions/8032566/emulate-super-in-...)
Are there any real advantages to the "set the prototype to this object" approach versus building it up by assigment?
function Animal(legs) {
this.legs = legs;
}
Animal.prototype.speed = function() {
return legs * 10;
}
util.inherits(Dog, Animal);
function Dog(name) {
this.constructor.super_.call(this, 4);
this.name = name;
}
Dog.prototype.speed = function() {
// I don't disagree that more sugar here would be good
return this.constructor.super_.prototype.speed.call(this) * 2;
}The problem I have is that the notion of a constructor function goes against prototypical OO.
In prototypical OO we just have objects and objects inherit from objects. there is no notion of a constructor function.
Also note that pd.make returns an object rather then a function.
It's simply a programming style I like, to think of my "class" object not as the constructor function but as the prototype object.
Not to mention that `x.prototype.foo = ...` is ugly.
var Animal = {
constructor: function () {
this.legs = legs;
},
speed: function () {
return this.legs * 10;
}
};
var Dog = pd.make(Animal, {
constructor: function (name) {
Animal.constructor.call(this, 4);
this.name = name;
},
speed: function () {
return Animal.speed.call(this) * 2;
}
});Beyond the need for calling the constructor (which I'm currently viewing it as an unnecessary hidrance [objects are already initialized]), Object.getPrototypeOf may provide a way out - but maybe not the way you intended. Have you considered it?
Object.getPrototypeOf(Child).constructor.apply(this, arguments);
I do think the Object.getPrototypeOf approach is feasible for methods.
If a single method calls a super method and that method calls another super method then it fails.
Object.getPrototypeOf(this).method