[go: up one dir, main page]
Scribd
Upload
165 views2 pages

Prototypal Inheritance Crockford

The document discusses prototypal inheritance in JavaScript. It explains that in JavaScript, objects inherit from other objects, but the language uses constructors instead of a direct inheritance operator. This obscures JavaScript's true prototypal nature. The author advocates using an "object" function to achieve true prototypal inheritance by returning a new empty object that inherits from an old object. He argues this prototypal model is more capable than classical inheritance and offers more expressive power.

Uploaded by

Anonymous 0PRCsW6
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
165 views2 pages

Prototypal Inheritance Crockford

The document discusses prototypal inheritance in JavaScript. It explains that in JavaScript, objects inherit from other objects, but the language uses constructors instead of a direct inheritance operator. This obscures JavaScript's true prototypal nature. The author advocates using an "object" function to achieve true prototypal inheritance by returning a new empty object that inherits from an old object. He argues this prototypal model is more capable than classical inheritance and offers more expressive power.

Uploaded by

Anonymous 0PRCsW6
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 2

Prototypal Inheritance https://crockford.com/javascript/prototypal.

html

Prototypal Inheritance in JavaScript


Douglas Crockford
www.crockford.com

Five years ago I wrote Classical Inheritance in JavaScript (Chinese Italian Japanese). It
showed that JavaScript is a class-free, prototypal language, and that it has sufficient
expressive power to simulate a classical system. My programming style has evolved
since then, as any good programmer's should. I have learned to fully embrace
prototypalism, and have liberated myself from the confines of the classical model.
My journey was circuitous because JavaScript itself is conflicted about its prototypal
nature. In a prototypal system, objects inherit from objects. JavaScript, however, lacks
an operator that performs that operation. Instead it has a new operator, such that
new f()

produces a new object that inherits from


f.prototype
This indirection was intended to make the language seem more familiar to classically
trained programmers, but failed to do that, as we can see from the very low opinion
Java programmers have of JavaScript. JavaScript's constructor pattern did not appeal to
the classical crowd. It also obscured JavaScript's true prototypal nature. As a result,
there are very few programmers who know how to use the language effectively.
Fortunately, it is easy to create an operator that implements true prototypal inheritance.
It is a standard feature in my toolkit, and I highly recommend it for yours.
function object(o) {
function F() {}
F.prototype = o;
return new F();
}

The object function untangles JavaScript's constructor pattern, achieving true


prototypal inheritance. It takes an old object as a parameter and returns an empty new
object that inherits from the old one. If we attempt to obtain a member from the new
object, and it lacks that key, then the old object will supply the member. Objects inherit
from objects. What could be more object oriented than that?
So instead of creating classes, you make prototype objects, and then use the object
function to make new instances. Objects are mutable in JavaScript, so we can augment
the new instances, giving them new fields and methods. These can then act as
prototypes for even newer objects. We don't need classes to make lots of similar objects.
For convenience, we can create functions which will call the object function for us,
and provide other customizations such as augmenting the new objects with privileged
functions. I sometimes call these maker functions. If we have a maker function that
calls another maker function instead of calling the object function, then we have a
parasitic inheritance pattern.
I have found that by using these tools, coupled with JavaScript's lambdas and object
quasi-literals, I can write well-structured programs that are large, complex, and

1 of 2 6/19/2020, 8:21 PM
Prototypal Inheritance https://crockford.com/javascript/prototypal.html

efficient. The classical object model is by far the most popular today, but I think that the
prototypal object model is more capable and offers more expressive power.
Learning these new patterns also made me a better classical programmer. Insights from
the dynamic world can have application in the static.
2006-06-07

Here is another formulation:


Object.prototype.begetObject = function () {
function F() {}
F.prototype = this;
return new F();
};

newObject = oldObject.begetObject();

2007-04-02

The problem with the object function is that it is global, and globals are clearly
problematic. The problem with Object.prototype.begetObject is that it trips up
incompetent programs, and it can produce unexpected results when begetObject is
overridden.
So I now prefer this formulation:
if (typeof Object.create !== 'function') {
Object.create = function (o) {
function F() {}
F.prototype = o;
return new F();
};
}
newObject = Object.create(oldObject);

2008-04-07

2 of 2 6/19/2020, 8:21 PM

You might also like