This AI is still in early stages of development.
function.inherit()
Syntax
myClass.inherit(mySuperclass);
inherit() replaces myClass.prototype so use it prior to defining any properties on the class prototype.
Parameters / functions
| Parameter / function | Type | Mandatory | Description | API Version |
|---|---|---|---|---|
| mySuperclass | Function |  | The superclass to inherit. Define methods and properties on the prototype chain.
| 1.0 |
| myClass | Function | | The class that will inherit the superclass. Properties defined on the class prototype will override properties of the same name on the superclass prototype, without affecting the superclass. Methods on your class can call superclass methods of the same name using object.super(). | 1.0 |
Return value
| Value | Type | Notes | API Version |
|---|---|---|---|
| <myClass> | Function | The class (function) that .inherit() was called on. | 1.0 |
Notes
Prototypal inheritance is how most of Javascript's inbuilt objects/classes work (such as Array, Function, Number, global, etc). uInherit() let's you do the same without the pain.
It works perfectly with Javascript's typeof operator, instanceof and also Type Checking and Property Definitions. The prototype chain depth (number of superclasses) is unlimited and ultimately ends with Object.prototype.
Prototypal inheritance is rampantly fast to instantiate because it's based on simple prototype chain manipulation. However, if your proto chains get too deep there can be a performance impact (although negligible on today's optimised JS compilers). Anything less than 10 levels deep will not have any impact on performance, and even deeper chains still probably won't have any noticeable effect based on my experience.
Example
// define your superclass in usual way
var mySuperclass = function BigBertha(args) { /* stuff */ } // constructor
mySuperclass.prototype.moo = function(args) { return "moo"; } // method
mySuperclass.prototype.bleh = function(args) { return "bertha"; } // method
mySuperclass.prototype.foo = "bar"; // property
mySuperclass.prototype.goo = "goo"; // property
// define constructor of your class
var myClass = function FooClass(args) { /* stuff */ }
// then immediately inherit the superclass before adding
// anything to the prototype of your class
myClass.inherit(mySuperclass);
// then you can start adding stuff to the class prototype
myClass.prototype.bleh = function() { return "bleh"; } // method
myClass.prototype.foo = "wobble"; // property
// instantiate instances of your class in the usual way
var foo = new myClass("whatever");
foo.foo; // "wobble" (not "bar")
foo.bleh(); // "bleh" (not "bertha")
foo.goo; // "goo"
foo.moo(); // "moo"
Contents
Jump to:
See also
- Class inheritance – original post about inherit() in the WZ forums, with a worked example of a prototype chain if you're not familiar with that sort of stuff
- OOP ECMAscript implementation – Brilliant blog post by Dmitry Soshnikov about prototypal inheritance in JS, on which inherit() is based
Inheritance Model
Topics:
- object.super() — Call a superclass method or constructor from within the class method (of same name) or constructor.
- function.inherit() — Simplifies the implementation and use of classical Javascript prototypal inheritance.