Prototypes in JavaScript

#atom
JavaScript is a prototype-based language, meaning it uses prototypes instead of classes (though ES6 introduced class syntax for familiarity).

How Prototypes Work in JavaScript:

Every object in JavaScript has a hidden [[Prototype]] property that points to another object or null.
When you access a property or method on an object, JavaScript first checks the object itself. If it doesn't find the property, it looks up the prototype chain.
The __proto__ property (deprecated but still used) and Object.getPrototypeOf() can be used to access an object's prototype.

Example:

// Create a prototype object
const animal = {
    makeSound() {
        console.log(`${this.name} makes a sound.`);
    }
};

// Create an object that inherits from the prototype
const dog = Object.create(animal);
dog.name = 'Rex';
dog.makeSound(); // "Rex makes a sound."

Constructor Functions and Prototypes:

In JavaScript, constructor functions are used to create objects with shared behavior via prototypes.
The prototype property of a constructor function is used to define methods and properties that will be inherited by all instances.

Example:

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

// Add a method to the prototype
Person.prototype.greet = function() {
    console.log(`Hello, my name is ${this.name}`);
};

// Create an instance
const alice = new Person('Alice');
alice.greet(); // "Hello, my name is Alice"

ES6 Classes and Prototypes:

ES6 introduced the class syntax, which is syntactic sugar over JavaScript's prototype-based inheritance.

Example:

class Person {
    constructor(name) {
        this.name = name;
    }
    greet() {
        console.log(`Hello, my name is ${this.name}`);
    }
}

const bob = new Person('Bob');
bob.greet(); // "Hello, my name is Bob"

3. Advantages of Prototypes

Memory Efficiency: Methods and properties are shared via the prototype chain, reducing memory usage.
Dynamic Behavior: Prototypes can be modified at runtime, allowing for flexible and dynamic object behavior.
Code Reusability: Prototypes enable inheritance and code reuse without classes.

4. Disadvantages of Prototypes

Complexity: Prototype chains can become difficult to understand and debug, especially in large codebases.
Performance: Deep prototype chains can lead to performance overhead due to property lookup.

Connections:

Sources:

From: Una breve guía a la programación y JavaScript