26. Explain the concept of prototypal inheritance in JavaScript.
medium
In JavaScript, prototypal inheritance is a mechanism that allows an object to inherit properties and methods from another object. This inheritance is achieved through the use of prototype chains, which are a hierarchy of objects that contain shared properties and methods.

Each object in JavaScript has a `prototype` property that specifies the parent object in the prototype chain. When we create a new object, it inherits all the properties and methods of its parent object through this prototype chain. We can also modify the prototype chain to add or remove objects from it.

Here's an example of prototypal inheritance in JavaScript:
// Create a base class with a method
function Animal(name) {
  this.name = name;
}

Animal.prototype.makeSound = function() {
  console.log("This animal makes a sound.");
};

// Create a derived class that inherits the method from the base class
function Dog(name) {
  Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.__proto__ = Animal.prototype;

Dog.prototype.makeSound = function() {
  console.log("This dog barks.");
};

// Create an instance of the derived class and call the makeSound method
const myDog = new Dog("Buddy");
myDog.makeSound();
In this example, we define a base class `Animal` with a method `makeSound`. We then create a derived class `Dog` that inherits the `makeSound` method from the `Animal` class. We achieve this by creating a new object using `Object.create` and setting its prototype to the prototype of the `Animal` class using the `__proto__` property. Finally, we modify the `makeSound` method in the `Dog` class to return "This dog barks.".
We can also add objects to the prototype chain to add new properties and methods to an object. For example:
// Create a base class with a method
function Animal(name) {
  this.name = name;
}

Animal.prototype.makeSound = function() {
  console.log("This animal makes a sound.");
};

// Add a method to the prototype chain for all objects of type Animal
Animal.prototype.eat = function() {
  console.log(this.name + " eats food.");
};

// Create a derived class that inherits the methods from the base class
function Dog(name) {
  Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.__proto__ = Animal.prototype;

// Call the eat method on an instance of the derived class
const myDog = new Dog("Buddy");
myDog.eat();
In this example, we add a new method `eat` to the prototype chain for all objects of type `Animal`. We then create a derived class `Dog` that inherits the `makeSound` and `eat` methods from the `Animal` class. Finally, we call the `eat` method on an instance of the `Dog` class.

In summary, prototypal inheritance in JavaScript allows an object to inherit properties and methods from another object through a prototype chain. This mechanism allows for code reuse and makes it easy to create new classes that inherit existing functionality.
PreviousNext