JavaScript is a versatile and powerful language, but some of its core concepts can be tricky to grasp, especially when it comes to prototypes and the behavior of the delete operator. In this article, we’ll answer the important question: What are JavaScript prototypes and the delete operator? and explore why using delete doesn’t remove inherited methods from objects.

---

What Are JavaScript Prototypes?

In JavaScript, prototypes are the mechanism by which objects inherit features from other objects. Every JavaScript object has an internal link to another object called its prototype. This prototype object can contain properties and methods that are shared among all objects inheriting from it.

For example:

function Person(name) {
  this.name = name;
}

Person.prototype.sayHello = function() {
  return `Hello, I'm ${this.name}`;
};

const alice = new Person('Alice');
console.log(alice.sayHello());  // Output: Hello, I'm Alice

Here, the method sayHello is defined on the Person.prototype. All instances of Person, like alice, inherit this method.

---

What Is the delete Operator in JavaScript?

The delete operator is used to remove a property from an object. However, it only works on the object’s own properties, meaning the properties that exist directly on the object itself — not properties inherited through the prototype chain.

Example:

const obj = { a: 1 };
delete obj.a;
console.log(obj.a);  // Output: undefined

---

Why Doesn’t delete Remove Inherited Methods?

Let’s consider this code:

const bob = new Person('Bob');
delete bob.sayHello;
console.log(bob.sayHello());

• Here, sayHello is not an own property of bob. Instead, it’s inherited from Person.prototype.
• The delete operator only removes own properties, so delete bob.sayHello does nothing.
• When bob.sayHello() is called, JavaScript looks up the prototype chain and finds sayHello on Person.prototype, so it works as expected.

---

How to Remove Inherited Methods?

To remove an inherited method for all instances, you must delete it from the prototype itself:

delete Person.prototype.sayHello;
console.log(bob.sayHello());  // Throws TypeError: bob.sayHello is not a function

This will remove sayHello from the prototype, so no instance will have access to it anymore.

---

Practical Tips for JavaScript Developers

• Use delete carefully — it only deletes own properties on an object.
• If you want to remove or override inherited methods, modify or delete them on the prototype.
• Always understand whether a property is own or inherited before using delete.
• Overusing delete can impact performance — consider setting properties to undefined or using other patterns when appropriate.

---

Conclusion

JavaScript prototypes are the backbone of inheritance in the language, enabling objects to share properties and methods efficiently. The delete operator works only on the object’s own properties and does not affect inherited ones, which is why deleting an inherited method on an instance doesn’t work.

By understanding these core concepts, you’ll avoid common pitfalls and write cleaner, more efficient JavaScript code.