This content originally appeared on DEV Community and was authored by Rohit Singh
Why Prototypes Matter 
Imagine you’re building a web app, and you want multiple objects to share the same behavior without duplicating code. Enter JavaScript prototypes—a powerful feature that lets objects inherit properties and methods from one another. If you’ve ever wondered how JavaScript’s “class-like” behavior works under the hood or how libraries like jQuery or frameworks like React leverage this, prototypes are the key. In this post, we’ll break down prototypes with a real-world analogy and a practical example you can try yourself.
The Basics of Prototypes 
In JavaScript, every object has a prototype, an object from which it inherits properties and methods. Think of it like a family recipe book passed down through generations. The book contains core recipes (methods), and each family member can add their own twist without rewriting the originals.
Here’s the gist:
Prototype: An object that other objects can inherit from.
Prototype Chain: When you access a property or method, JavaScript looks at the object first, then climbs up the prototype chain until it finds it (or doesn’t).
proto vs. prototype: __proto__is the actual link to an object’s prototype, whileprototypeis a property on constructor functions used to set up inheritance.
Let’s make this concrete with a real-world example.
Real-World Example: The Family Recipe Book 
Imagine a family recipe book for baking cakes. The book has a core bakeCake method that every family member uses. Each member (object) can add their own ingredients (properties) or tweaks (methods) while still relying on the core recipe.
In JavaScript, this looks like creating a Cake constructor and adding shared methods to its prototype:
// Constructor function (the recipe book) 📖
function Cake(flavor) {
this.flavor = flavor;
}
// Shared method on the prototype 🎂
Cake.prototype.bakeCake = function() {
console.log(`Baking a ${this.flavor} cake with the family recipe!`);
};
// Create two family members (objects)
const vanillaCake = new Cake("vanilla");
const chocolateCake = new Cake("chocolate");
vanillaCake.bakeCake(); // Baking a vanilla cake with the family recipe!
chocolateCake.bakeCake(); // Baking a chocolate cake with the family recipe!
Here, bakeCake is stored on Cake.prototype, so both vanillaCake and chocolateCake share it without duplicating the method in memory. This efficiency saves memory and mimics inheritance in the real world.
Deep Dive: How Prototypes Work 
Let’s extend our cake example to show how the prototype chain works. Suppose the family also has a secret frosting recipe that only some cakes use. We can add it to the prototype and override it for specific cakes:
// Add a frosting method to the prototype 🧁
Cake.prototype.addFrosting = function() {
console.log(`Adding standard buttercream frosting to ${this.flavor} cake.`);
};
// Create a special cake with a custom frosting
const strawberryCake = new Cake("strawberry");
strawberryCake.addFrosting = function() {
console.log(`Adding whipped cream frosting to ${this.flavor} cake.`);
};
strawberryCake.bakeCake(); // Baking a strawberry cake with the family recipe!
strawberryCake.addFrosting(); // Adding whipped cream frosting to strawberry cake.
chocolateCake.addFrosting(); // Adding standard buttercream frosting to chocolate cake.
When we call strawberryCake.addFrosting(), JavaScript checks strawberryCake first and finds the custom addFrosting method. For chocolateCake.addFrosting(), it doesn’t find the method on the object, so it looks up the prototype chain and uses Cake.prototype.addFrosting. This chain is what makes prototypes so flexible.
You can inspect the prototype chain in your browser’s console:
console.log(strawberryCake.__proto__ === Cake.prototype); // true
console.log(strawberryCake.__proto__.__proto__); // Object.prototype
The chain ends at Object.prototype, which provides universal methods like toString().
Common Use Cases for Prototypes 
Prototypes are everywhere in JavaScript:
Libraries and Frameworks: jQuery’s $object uses prototypes to share methods across all jQuery objects. React components often inherit shared behavior via prototypes or classes (which use prototypes under the hood).
Custom Objects: When building a game, you might have a Characterprototype with methods likemove()orattack(), shared by all characters (e.g., players, enemies).
Performance Optimization: Prototypes save memory by sharing methods across instances, crucial for large-scale apps.
For example, in a game, you might have:
function Character(name) {
this.name = name;
this.health = 100;
}
Character.prototype.attack = function(target) {
console.log(`${this.name} attacks ${target.name}!`);
};
const player = new Character("Hero");
const enemy = new Character("Dragon");
player.attack(enemy); // Hero attacks Dragon!
This ensures all characters share the attack method efficiently.
Wrapping Up 
JavaScript prototypes are like a shared family recipe book: they let objects inherit behavior efficiently, saving memory and enabling powerful inheritance patterns. By understanding the prototype chain, you can write cleaner, more efficient code and better grasp how JavaScript’s object model works.
Prototypes are a cornerstone of JavaScript, and mastering them unlocks a deeper understanding of the language. Whether you’re building a game, a web app, or just experimenting, prototypes are a tool you’ll use again and again.
Try It Yourself! 
Try the cake or character examples in your browser’s console! Play with adding methods to the prototype or overriding them on specific objects. Have questions or cool prototype examples of your own? Share them in the comments. Happy coding!
Rohit Singh – Medium
Read writing from Rohit Singh on Medium. Full-stack developer with 6+ years in Angular, Node.js & AWS. Sharing tips, best practices & real-world lessons from building scalable apps.
medium.com
This content originally appeared on DEV Community and was authored by Rohit Singh