Title: Prototype Inheritance Bug — Shared Array Leaks Tenant Data
Open Graph Title: Prototype Inheritance Bug — Shared Array Leaks Tenant Data
Description: A shared array on a prototype caused cross-tenant data leakage. Avoid this by never mutating shared prototypes. Production lessons from real incidents.
Open Graph Description: A shared array on a prototype caused cross-tenant data leakage. Avoid this by never mutating shared prototypes. Production lessons from real incidents.
Opengraph URL: https://thecodeforge.io/javascript/prototypes-inheritance-javascript/
Domain: thecodeforge.io
{
"@context": "https://schema.org",
"@type": "TechArticle",
"mainEntityOfPage": {
"@type": "WebPage",
"@id": "https://thecodeforge.io/javascript/prototypes-inheritance-javascript/"
},
"headline": "Prototype Inheritance Bug — Shared Array Leaks Tenant Data",
"description": "A shared array on a prototype caused cross-tenant data leakage. Avoid this by never mutating shared prototypes. Production lessons from real incidents.",
"keywords": "Prototype Inheritance Bug — Shared Array Leaks Tenant Data, JavaScript, Intermediate, Advanced JS, A shared array on a prototype caused cross-tenant data leakage. Avoid this by never mutating shared prototypes. Production lessons from real incidents.",
"proficiencyLevel": "Intermediate",
"author": {
"@type": "Person",
"@id": "https://thecodeforge.io/about/#naren",
"name": "Naren",
"url": "https://thecodeforge.io/about/"
},
"publisher": {
"@type": "Organization",
"@id": "https://thecodeforge.io/#org",
"name": "TheCodeForge",
"url": "https://thecodeforge.io",
"logo": {"@type": "ImageObject", "url": "https://thecodeforge.io/assets/og-image.png"}
},
"datePublished": "2026-03-05T00:00:00+00:00",
"dateModified": "2026-08-30T00:00:00+00:00",
"url": "https://thecodeforge.io/javascript/prototypes-inheritance-javascript/",
"inLanguage": "en",
"educationalLevel": "Intermediate",
"image": "https://thecodeforge.io/assets/og-image.png",
"isPartOf": {"@id": "https://thecodeforge.io/#website"}
}
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [
{"@type": "ListItem", "position": 1, "name": "Home", "item": "https://thecodeforge.io/"},
{"@type": "ListItem", "position": 2, "name": "JavaScript", "item": "https://thecodeforge.io/javascript/"},
{"@type": "ListItem", "position": 3, "name": "Prototype Inheritance Bug — Shared Array Leaks Tenant Data", "item": "https://thecodeforge.io/javascript/prototypes-inheritance-javascript/"}
]
}
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [
{
"@type": "Question",
"name": "What is the prototype chain in JavaScript?",
"acceptedAnswer": {
"@type": "Answer",
"text": "The prototype chain is the mechanism JavaScript uses to look up properties and methods. Every object has a hidden [[Prototype]] link to another object. When you access a property, JS first checks the object itself, then walks up the chain through each linked object until it either finds the property or reaches null at the end of the chain."
}
},
{
"@type": "Question",
"name": "What is the difference between classical inheritance and prototypal inheritance?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Classical inheritance (Java, C++) copies a blueprint — the class — into new instances at compile time. Prototypal inheritance (JavaScript) links objects together at runtime. Instances don't copy methods; they delegate to their prototype. This means you can modify the prototype after instances are created and all instances immediately see the change."
}
},
{
"@type": "Question",
"name": "Does using ES6 classes mean JavaScript is no longer prototype-based?",
"acceptedAnswer": {
"@type": "Answer",
"text": "No. ES6 classes are syntax on top of the same prototype system. Running class Dog extends Animal creates a constructor function and wires Dog.prototype to Animal.prototype using Object.create() — exactly as you'd do manually. You can verify this by checking Object.getPrototypeOf(Dog.prototype) === Animal.prototype, which returns true for any class hierarchy."
}
},
{
"@type": "Question",
"name": "What is the best way to inspect an object's prototype chain?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Use Object.getPrototypeOf() in a loop until null. Or in browser DevTools, console.dir(obj) shows the full chain. Avoid __proto__ in production code."
}
},
{
"@type": "Question",
"name": "How do I prevent prototype pollution in my application?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Use Object.create(null) for objects that serve as maps, always filter __proto__ and constructor keys when merging user input, freeze Object.prototype in critical environments, and use libraries with built-in pollution prevention (e.g., lodash's cloneDeep has patches but still sanitize yourself)."
}
},
{
"@type": "Question",
"name": "Does for..in loop over inherited properties?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Yes — for..in iterates all enumerable properties, including inherited ones from the prototype chain. This is a frequent source of bugs when you add methods to a shared prototype and then iterate object instances. Use Object.keys(obj) for own-only enumerable properties, or guard with if (Object.hasOwn(obj, key)) inside the loop. Object.hasOwn() is the modern replacement for the older obj.hasOwnProperty(key)."
}
},
{
"@type": "Question",
"name": "What is the difference between __proto__ and prototype?",
"acceptedAnswer": {
"@type": "Answer",
"text": "__proto__ is the actual link between an object instance and its prototype — it's the [[Prototype]] internal slot exposed as a property. prototype is a property on constructor functions that becomes the [[Prototype]] of objects created with new. When you write new Foo(), the resulting object's __proto__ is set to Foo.prototype. They're two sides of the same chain: prototype defines it, __proto__ accesses it."
}
},
{
"@type": "Question",
"name": "Why does this lose its value when you extract a prototype method?",
"acceptedAnswer": {
"@type": "Answer",
"text": "Because this is determined by the call site, not by where the method is defined. When you write const fn = obj.method and then call fn(), there is no object before the dot — so this becomes undefined in strict mode (or the global object in sloppy mode). The method travels without its context. Fix it with const fn = obj.method.bind(obj) to permanently attach obj as this, or use an arrow function wrapper: const fn = () => obj.method()."
}
},
{
"@type": "Question",
"name": "What is the SmooshGate incident and what does it prove about monkey patching?",
"acceptedAnswer": {
"@type": "Answer",
"text": "In 2018, TC39 proposed Array.prototype.flatten(). It turned out MooTools (a library from 2006 still running on millions of sites) had already added Array.prototype.flatten with different semantics. Browsers couldn't implement the new flatten without breaking those sites. The proposal had to be renamed to Array.prototype.flat(). The lesson: the moment you patch a built-in prototype, you've made a global contract that is nearly impossible to revoke. Never patch built-ins — use standalone utility functions instead."
}
}
]
}
| og:type | website |
| og:image | https://thecodeforge.io/assets/og-image.png |
| og:image:width | 1200 |
| og:image:height | 630 |
Links:
Viewport: width=device-width, initial-scale=1.0
Robots: max-image-preview:large