Explain prototypal inheritance in JavaScript. How does it differ from classical inheritance?

Question

Accepted Answer

Prototypal inheritance is JavaScript's mechanism for objects to inherit properties and methods from other objects. Every object has an internal link to another object called its prototype.

When you access a property on an object, JavaScript first looks at the object itself. If the property is not found, it looks at the object's prototype. This continues up the prototype chain until the property is found or the chain ends at null.

Here is a simple example. When you create an array with const arr = [1, 2, 3], the array object inherits methods like map, filter, and forEach from Array.prototype. These methods are not on the array itself but on its prototype.

The difference from classical inheritance is significant. In classical languages like Java, classes are blueprints that create instances. Inheritance is defined at the class level, and you cannot change it at runtime.

In JavaScript, there are no true classes, only objects. The class syntax introduced in ES6 is syntactic sugar over prototypes. Objects can directly inherit from other objects. You can modify prototypes at runtime, adding or changing methods that all instances will see.

Creating inheritance manually looks like this. You create an object with Object.create(parentObject). The new object's prototype is set to parentObject. Any property access that fails on the new object will look in parentObject.

The prototype chain is powerful but can be confusing. Modern JavaScript often uses class syntax for familiarity, but understanding prototypes helps debug inheritance issues and understand how built-in methods work.