#atom
ID: CS-012
Date: [Insert Date]

Content:
The concepts of prototypes and classes represent two different approaches to object-oriented programming (OOP). While both aim to achieve code reuse and organization, they differ fundamentally in their principles and implementation.

1. Key Differences in Principle

1. Inheritance Mechanism:

• Classes:
  • Use a class-based inheritance model.
  • Objects are created from classes, which serve as blueprints.
  • Inheritance is hierarchical: a subclass inherits from a superclass.
• Prototypes:
  • Use a prototype-based inheritance model.
  • Objects are created directly from other objects (prototypes).
  • Inheritance is delegation-based: objects delegate property access to their prototype.

2. Object Creation:

• Classes:
  • Objects are instantiated from classes using constructors.
  • The class defines the structure and behavior of the object.
• Prototypes:
  • Objects are created by cloning existing objects (prototypes).
  • The prototype serves as a template for the new object.

3. Flexibility:

• Classes:
  • More rigid structure due to the class hierarchy.
  • Changes to a class affect all instances.
• Prototypes:
  • More flexible and dynamic.
  • Objects can be modified at runtime without affecting other objects.

4. Memory Usage:

• Classes:
  • Methods are typically stored in the class, and instances reference the class for method access.
• Prototypes:
  • Methods are stored in the prototype, and instances delegate method access to the prototype.

2. Conceptual Comparison

3. Example in Principle

Class-Based Approach:

class Animal {
    constructor(name) {
        this.name = name;
    }
    speak() {
        console.log(`${this.name} makes a sound.`);
    }
}

class Dog extends Animal {
    speak() {
        console.log(`${this.name} barks.`);
    }
}

const dog = new Dog("Rex");
dog.speak(); // "Rex barks."

Prototype-Based Approach:

const animal = {
    speak() {
        console.log(`${this.name} makes a sound.`);
    }
};

const dog = Object.create(animal);
dog.name = "Rex";
dog.speak = function() {
    console.log(`${this.name} barks.`);
};

dog.speak(); // "Rex barks."

4. When to Use Which?

• Use Classes:
  • When you need a clear, hierarchical structure.
  • When working in languages that are class-based (e.g., Java, Python).
• Use Prototypes:
  • When you need dynamic, flexible object creation.
  • When working in prototype-based languages (e.g., JavaScript).

Connections:

• CS-011: Classes in Programming
• JS-010: Prototypes in JavaScript
• JS-011: Classes in JavaScript

Connections:

Sources:

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