Definizione e utilizzo delle classi di TypeScript

Le classi di TypeScript sono uno strumento chiaro e strutturato per organizzare i dati e i comportamenti in un oggetto. In questo modo puoi modellare più facilmente le entità e i concetti nel tuo codice.

A cosa servono le classi di TypeScript?

Le classi sono un concetto chiave del linguaggio di programmazione TypeScript, che si basa su JavaScript. Costituiscono un metodo strutturato per la definizione di oggetti e per l’applicazione della programmazione orientata agli oggetti (OOP). Queste classi ricordano i progetti per la costruzione di oggetti che raccolgono in modo logico i dati e i metodi che sono in correlazione logica fra loro.

TypeScript contiene tutte le funzioni di JavaScript e, in aggiunta, la tipizzazione statica. In questo modo è possibile indicare tipi di dati per le funzioni di TypeScript, variabili e classi al fine di rilevare gli errori in fase di compilazione. Oltre alla sicurezza rispetto al tipo, le classi di TypeScript supportano anche concetti come l’ereditarietà e l’astrazione, che agevolano lo sviluppo di applicazioni complesse.

Le classi di TypeScript ti permettono di realizzare una gerarchia chiara delle classi che ereditano proprietà e metodi. Questa possibilità va a vantaggio del riutilizzo del codice e della strutturazione. I costruttori nelle classi permettono inoltre di inizializzare le istanze e garantire la coerenza nella creazione degli oggetti.

La sintassi delle classi di TypeScript

La scrittura di classi di TypeScript è simile a quella di ECMAScript 6 (ES6) ed è una versione estesa della sintassi delle classi di JavaScript. Una classe in TypeScript può contenere diversi elementi per definire la struttura e il comportamento di oggetti. I componenti principali e fondamentali sono:

• Proprietà
• Costruttore
• Metodi

Proprietà

Le proprietà (Properties) determinano lo stato di un oggetto. Memorizzano i valori dei dati e possono contenere annotazioni dei tipi di dati in modo che presentino solo valori validi.

class ClassName {
    propertyName: propertyType;
}

• ClassName: il nome della classe
• propertyName: il nome della proprietà che desideri definire
• propertyType: il tipo di dati della proprietà

Un esempio pratico:

class Person {
    name: string;
}

Per prima cosa, definiamo una classe Person con una proprietà name del tipo string. Questo significa che le istanze della classe Person hanno una proprietà name in cui sono memorizzate catene di caratteri (stringhe).

Costruttore

Il costruttore in TypeScript è un metodo speciale che viene richiamato quando si crea un’istanza (un oggetto) di una classe. È necessario per eseguire l’inizializzazione delle proprietà di un oggetto. Questo componente definisce essenzialmente lo stato iniziale di un’istanza. Nel costruttore è possibile indicare dei parametri per trasmettere valori in fase di istanziazione delle classi di TypeScript.

La sintassi fondamentale di un costruttore in TypeScript è la seguente:

class ClassName {
    constructor(parameter1: Type1, parameter2: Type2, ...) {
    }
}

• constructor: ogni classe può avere un singolo costruttore. Se non è definito nessun costruttore, ne viene creato uno vuoto per impostazione predefinita.
• parameter: Type: i parametri sono opzionali e dipendono dalla classe e dai suoi requisiti. I parametri devono essere caratterizzati dai rispettivi tipi di dati.

Un esempio di costruttore:

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

Nel nostro esempio, la classe Person presenta un costruttore che accetta due parametri firstName e lastName. Al momento della creazione di un’istanza di questa classe, vengono assegnati questi parametri e il costruttore inizializza le proprietà firstName e lastName dell’istanza con i valori corrispondenti. La parola chiave this si riferisce all’attuale istanza della classe sulla quale viene eseguito il codice.

Metodi

In TypeScript i metodi sono funzioni definite in classi e sulle quali è possibile applicare delle istanze. I metodi ti permettono di eseguire determinate azioni o operazioni nel contesto di una classe.

class ClassName {
    // ...
    methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
    }
    // ...
}

• methodName: nome del metodo.
• parameter: Type: parametri opzionali accettati dal metodo.
• ReturnType: il tipo di dati che determina il valore restituito dal metodo. Se il metodo non restituisce nessun valore, puoi indicare void.

Per accedere a una proprietà o per richiamare un metodo su un’istanza di una classe, utilizza l’operatore punto ., seguito dal nome del metodo e dagli argomenti necessari, nel caso in cui il metodo preveda dei parametri.

class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    getFullName(): string {
        return this.firstName + " " + this.lastName;
    }
}
const person = new Person("John", "Doe");
const fullName = person.getFullName();

Il metodo getFullName serve a creare il nome completo della persona e a restituirlo. Accede ai valori delle proprietà firstName e lastName, che sono stati definiti nella classe e inizializzati nel costruttore. L’oggetto person è creato per mezzo della parola chiave new seguita dal nome della classe e dai rispettivi parametri. Il metodo concatena le due catene di caratteri una volta richiamato e restituisce il nome completo sotto forma di stringa. L’output per l’oggetto person è quindi “John Doe”.

Esempi di applicazione delle classi di TypeScript

Le classi di TypeScript dispongono di diversi meccanismi per organizzare e controllare la struttura e il comportamento degli oggetti. Nelle parti seguenti ti mostriamo alcuni concetti per l’utilizzo delle classi di TypeScript.

Visibilità

La visibilità nelle classi di TypeScript regola l’accesso alle proprietà e ai metodi all’interno e all’esterno della classe. TypeScript offre tre modificatori della visibilità: public, private e protected.

• public (standard): le proprietà e i metodi caratterizzati da public possono essere richiamati da ogni posizione, sia all’interno che all’esterno della classe.

• private: private si riferisce a proprietà e metodi che possono essere richiamati solo all’interno della classe stessa. Sono inaccessibili per le parti di codice esterne.

• protected: le proprietà e i metodi caratterizzati da protected possono essere richiamati dalla classe stessa e da classi derivate (nell’ereditarietà), ma non da codice esterno.

class Person {
    private socialSecurityNumber: string;
    constructor(ssn: string) {
        this.socialSecurityNumber = ssn;
    }
    greet() {
        console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber);
    }
}
const person = new Person("123-45-6789");
person.greet();

In questo esempio, socialSecurityNumber è una proprietà privata alla quale è possibile accedere solo all’interno della classe Person. È comunque possibile richiamare il metodo greet dall’esterno.

Ereditarietà

L’ereditarietà è un concetto fondamentale della programmazione orientata agli oggetti (OOP), utilizzata in TypeScript e in molti altri linguaggi di programmazione web. Permette la creazione di una nuova classe partendo da una classe base o da una superclasse già esistenti. La classe derivata (sottoclasse) eredita quindi le proprietà e i metodi della classe base e può espanderli o adattarli.

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    makeSound() {
        console.log("Some generic sound");
    }
}
class Dog extends Animal {
    makeSound() {
        console.log(this.name + " barks");
    }
}
const myDog = new Dog("Buddy");
myDog.makeSound();

In questo caso, la classe Dog eredita dalla classe base Animal tramite la parola chiave extends. La classe derivata Dog sovrascrive il metodo makeSound per aggiungere un comportamento specifico mentre acquisisce la proprietà name da Animal.

Readonly

La parola chiave readonly è utilizzabile per dichiarare come protette da scrittura le proprietà delle classi di TypeScript o degli oggetti. In pratica non è più possibile cambiare il valore di una proprietà protetta da scrittura dopo la sua inizializzazione.

class Circle {
    readonly pi: number = 3.14159;
    radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    getArea() {
        return this.pi    *this.radius*    this.radius;
    }
}
const myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: ≈ 78,54

Nel nostro esempio, la proprietà pi è protetta da scrittura ed è inizializzata nel costruttore. Dopo l’inizializzazione non è più possibile cambiare pi. Tentando di modificare il valore di pi dopo l’inizializzazione, TypeScript genera un errore di compilazione.