JavaScript, Prototypal Inheritance in JS

Prototypal Inheritance in JS
Explin and illustrate Prototypal Inheritance in JS
Answer: Prototypal inheritance is a feature in JavaScript that allows objects to inherit properties and methods from other objects. This is done through a prototype chain, where one object (the prototype) serves as a template for another object.
## Explanation1. Prototype: An object from which other objects inherit properties.
2. Prototype Chain: A chain of objects connected through their prototypes. When an object tries to access a property or method, JavaScript first looks at the object itself. If the property/method is not found, it moves up the prototype chain until it finds the property/method or reaches the end of the chain (null).

#### Example 1: Using Object.create
The 'Object.create' method creates a new object with the specified prototype object and properties.

const person = {
greet() {
console.log('Hello, my name is ${this.name}');
}
};
const john = Object.create(person);
john.name = 'John';
john.greet(); // Output: Hello, my name is John

In this example, 'john' inherits the 'greet' method from the 'person' object. When 'john.greet()' is called, it uses the inherited method but with 'john''s own 'name' property.Constructor functions and the 'new' keyword can also be used to implement prototypal inheritance.

function Person(name) {
this.name = name;
}
Person.prototype.greet = function() {
console.log('Hello, my name is ${this.name}');
};
const jane = new Person('Jane');
jane.greet(); // Output: Hello, my name is Jane

In this example, 'Person' is a constructor function, and 'jane' is an instance of 'Person'. The 'greet' method is added to 'Person.prototype', making it available to all instances of 'Person'.When a property or method is accessed on an object, JavaScript will look for the property in the following order:
1. The object itself.
2. The object's prototype.
3. The prototype's prototype.
4. This continues until the end of the prototype chain (null) is reached.

console.log(jane.hasOwnProperty('name')); // true
console.log(jane.hasOwnProperty('greet')); // false
console.log('greet' in jane); // true

Here, 'hasOwnProperty' checks if the property is directly on the object, whereas the 'in' operator checks the entire prototype chain.
## Illustration
To visualize the prototype chain, consider the following diagram:

Object.prototype
^
|
Person.prototype
^
|
{ name: "Jane" }

In this chain:
- '{ name: "Jane" }' inherits from 'Person.prototype'.
- 'Person.prototype' inherits from 'Object.prototype'.
## Summary
Prototypal inheritance in JavaScript allows objects to inherit properties and methods from other objects, creating a flexible and dynamic inheritance model. This can be achieved using methods like 'Object.create', constructor functions, and the 'new' keyword.