Come utilizzare le classi TypeScript con semplici esempi

TypeScript apporta potenti funzionalità a JavaScript, tra cui il concetto di classi, che consente la programmazione orientata agli oggetti. Le classi forniscono un modello per la creazione di oggetti, l'incapsulamento dei dati e la definizione dei comportamenti. Questa guida ti guiderà attraverso le basi delle classi TypeScript con semplici esempi.

Cos'è una classe?

Una classe è un modello per la creazione di oggetti con proprietà e metodi predefiniti. Aiuta a organizzare il codice, promuovendo la riutilizzabilità e creando applicazioni scalabili. Le classi in TypeScript funzionano in modo simile alle classi in altri linguaggi di programmazione orientati agli oggetti.

Definizione di una classe di base

Per definire una classe in TypeScript, utilizzare la parola chiave class seguita dal nome della classe e da una serie di parentesi graffe contenenti proprietà e metodi.

Esempio di classe base

Di seguito è riportato un esempio di una semplice classe Person con proprietà e un metodo:

class Person {
  name: string;
  age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  greet(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

const person1 = new Person("Alice", 30);
person1.greet(); // Output: Hello, my name is Alice and I am 30 years old.

In questo esempio, la classe Person ha due proprietà: name e age. Il metodo costruttore inizializza queste proprietà e il metodo greet restituisce un messaggio di saluto.

Modificatori di accesso

TypeScript fornisce tre modificatori di accesso per controllare la visibilità dei membri della classe:

• public: I membri sono accessibili da qualsiasi luogo (predefinito).
• private: I membri sono accessibili solo all'interno della classe.
• protected: I membri sono accessibili all'interno della classe e delle sue sottoclassi.

Utilizzo dei modificatori di accesso

Ecco come puoi utilizzare i modificatori di accesso in una classe TypeScript:

class Animal {
  public name: string;
  private age: number;

  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  public getAge(): number {
    return this.age;
  }
}

const dog = new Animal("Buddy", 5);
console.log(dog.name); // Output: Buddy
console.log(dog.getAge()); // Output: 5
// console.log(dog.age); // Error: 'age' is private and only accessible within class 'Animal'.

In questo esempio, name è una proprietà pubblica, accessibile dall'esterno della classe, mentre age è una proprietà privata, accessibile solo all'interno della classe.

Ereditarietà in TypeScript

TypeScript supporta l'ereditarietà, che consente a una classe di ereditare proprietà e metodi da un'altra classe. Ciò aiuta a riutilizzare il codice e a creare una gerarchia di classi.

Esempio di eredità

Di seguito è riportato un esempio di una classe Cane che eredita da una classe base Animale:

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  constructor(name: string) {
    super(name); // Call the constructor of the base class
  }

  makeSound(): void {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Output: Buddy barks.

In questo esempio, la classe Dog estende la classe Animal e sovrascrive il metodo makeSound.

Getter e setter

TypeScript consente di definire getter e setter per le proprietà, fornendo un accesso controllato ai membri della classe.

Esempio di getter e setter

class Person {
  private _name: string;

  constructor(name: string) {
    this._name = name;
  }

  get name(): string {
    return this._name;
  }

  set name(newName: string) {
    if (newName) {
      this._name = newName;
    } else {
      console.log("Name cannot be empty.");
    }
  }
}

const person = new Person("Alice");
console.log(person.name); // Output: Alice
person.name = "Bob";
console.log(person.name); // Output: Bob

In questo esempio, la proprietà name viene utilizzata per accedervi e modificarla tramite i metodi getter e setter.

Conclusione

Le classi TypeScript sono un modo potente per scrivere codice orientato agli oggetti in modo pulito ed efficiente. Forniscono un modo strutturato per definire proprietà, metodi, modificatori di accesso, ereditarietà e altro. Comprendendo come usare le classi TypeScript, puoi scrivere codice più robusto e gestibile per le tue applicazioni.