Cosa sono i prototipi in JavaScript?

In JavaScript, gli oggetti possono ereditare proprietà e metodi da altri oggetti attraverso il meccanismo dei prototipi. Ogni oggetto in JavaScript ha una proprietà interna nascosta [[Prototype]], che punta a un altro oggetto, il suo prototipo. Quando si accede a una proprietà o metodo di un oggetto, il motore JavaScript lo cerca prima nell'oggetto stesso. Se non lo trova, si rivolge alla proprietà [[Prototype]] e cerca nel prototipo. Questo processo si ripete lungo la catena dei prototipi fino a trovare la proprietà o raggiungere null (fine della catena).

Concetti principali:

• Catenza di prototipi: Sequenza di oggetti collegati tramite la proprietà [[Prototype]].
• Eredità: Gli oggetti ereditano proprietà e metodi dai loro prototipi.
• __proto__: Proprietà storicamente usata (anche se non standardizzata inizialmente) per accedere a [[Prototype]]. Attualmente, si preferisce usare Object.getPrototypeOf().
• prototype: Proprietà del costruttore a cui [[Prototype]] fa riferimento nelle istanze create con quel costruttore.

Esempio con costruttore e prototipo:

// Costruttore
function Person(name, age) {
  this.name = name;
  this.age = age;
}

// Aggiungi metodo al prototipo
Person.prototype.sayHello = function() {
  console.log("Ciao, il mio nome è " + this.name);
};

// Crea un'istanza
const person1 = new Person("Alice", 30);

// Chiama il metodo dal prototipo
person1.sayHello(); // Output: Ciao, il mio nome è Alice

// Accesso al prototipo dell'istanza
console.log(Object.getPrototypeOf(person1) === Person.prototype); // Output: true

In questo esempio:

• Person è una funzione costruttore.
• Person.prototype è l'oggetto che funge da prototipo per tutte le istanze create con new Person().
• sayHello è un metodo aggiunto al prototipo. Tutte le istanze di Person ereditano questo metodo.
• Quando si chiama person1.sayHello(), il motore JavaScript cerca sayHello in person1. Se non lo trova, si rivolge al [[Prototype]] di person1 (che è uguale a Person.prototype) e trova il metodo lì.

I prototipi consentono un uso efficiente della memoria, poiché i metodi e le proprietà comuni sono memorizzati nel prototipo, anziché duplicati in ogni istanza di oggetto.