De­fi­ni­zio­ne e utilizzo delle classi di Ty­pe­Script

Le classi di Ty­pe­Script sono uno strumento chiaro e strut­tu­ra­to per or­ga­niz­za­re i dati e i com­por­ta­men­ti in un oggetto. In questo modo puoi modellare più fa­cil­men­te le entità e i concetti nel tuo codice.

A cosa servono le classi di Ty­pe­Script?

Le classi sono un concetto chiave del lin­guag­gio di pro­gram­ma­zio­ne Ty­pe­Script, che si basa su Ja­va­Script. Co­sti­tui­sco­no un metodo strut­tu­ra­to per la de­fi­ni­zio­ne di oggetti e per l’ap­pli­ca­zio­ne della pro­gram­ma­zio­ne orientata agli oggetti (OOP). Queste classi ricordano i progetti per la co­stru­zio­ne di oggetti che rac­col­go­no in modo logico i dati e i metodi che sono in cor­re­la­zio­ne logica fra loro.

Ty­pe­Script contiene tutte le funzioni di Ja­va­Script e, in aggiunta, la ti­piz­za­zio­ne statica. In questo modo è possibile indicare tipi di dati per le funzioni di Ty­pe­Script, variabili e classi al fine di rilevare gli errori in fase di com­pi­la­zio­ne. Oltre alla sicurezza rispetto al tipo, le classi di Ty­pe­Script sup­por­ta­no anche concetti come l’ere­di­ta­rie­tà e l’astra­zio­ne, che agevolano lo sviluppo di ap­pli­ca­zio­ni complesse.

Le classi di Ty­pe­Script ti per­met­to­no di rea­liz­za­re una gerarchia chiara delle classi che ereditano proprietà e metodi. Questa pos­si­bi­li­tà va a vantaggio del riu­ti­liz­zo del codice e della strut­tu­ra­zio­ne. I co­strut­to­ri nelle classi per­met­to­no inoltre di ini­zia­liz­za­re le istanze e garantire la coerenza nella creazione degli oggetti.

La sintassi delle classi di Ty­pe­Script

La scrittura di classi di Ty­pe­Script è simile a quella di EC­MA­Script 6 (ES6) ed è una versione estesa della sintassi delle classi di Ja­va­Script. Una classe in Ty­pe­Script può contenere diversi elementi per definire la struttura e il com­por­ta­men­to di oggetti. I com­po­nen­ti prin­ci­pa­li e fon­da­men­ta­li sono:

• Proprietà
• Co­strut­to­re
• Metodi

Proprietà

Le proprietà (Pro­per­ties) de­ter­mi­na­no lo stato di un oggetto. Me­mo­riz­za­no i valori dei dati e possono contenere an­no­ta­zio­ni dei tipi di dati in modo che pre­sen­ti­no solo valori validi.

class ClassName {
    propertyName: propertyType;
}

• ClassName: il nome della classe
• pro­per­ty­Na­me: il nome della proprietà che desideri definire
• pro­per­ty­Ty­pe: 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 me­mo­riz­za­te catene di caratteri (stringhe).

Co­strut­to­re

Il co­strut­to­re in Ty­pe­Script è un metodo speciale che viene ri­chia­ma­to quando si crea un’istanza (un oggetto) di una classe. È ne­ces­sa­rio per eseguire l’ini­zia­liz­za­zio­ne delle proprietà di un oggetto. Questo com­po­nen­te definisce es­sen­zial­men­te lo stato iniziale di un’istanza. Nel co­strut­to­re è possibile indicare dei parametri per tra­smet­te­re valori in fase di istan­zia­zio­ne delle classi di Ty­pe­Script.

La sintassi fon­da­men­ta­le di un co­strut­to­re in Ty­pe­Script è la seguente:

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

• con­struc­tor: ogni classe può avere un singolo co­strut­to­re. Se non è definito nessun co­strut­to­re, ne viene creato uno vuoto per im­po­sta­zio­ne pre­de­fi­ni­ta.
• parameter: Type: i parametri sono opzionali e dipendono dalla classe e dai suoi requisiti. I parametri devono essere ca­rat­te­riz­za­ti dai ri­spet­ti­vi tipi di dati.

Un esempio di co­strut­to­re:

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 co­strut­to­re che accetta due parametri firstName e lastName. Al momento della creazione di un’istanza di questa classe, vengono assegnati questi parametri e il co­strut­to­re ini­zia­liz­za le proprietà firstName e lastName dell’istanza con i valori cor­ri­spon­den­ti. La parola chiave this si riferisce all’attuale istanza della classe sulla quale viene eseguito il codice.

Metodi

In Ty­pe­Script i metodi sono funzioni definite in classi e sulle quali è possibile applicare delle istanze. I metodi ti per­met­to­no di eseguire de­ter­mi­na­te azioni o ope­ra­zio­ni nel contesto di una classe.

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

• me­thod­Na­me: nome del metodo.
• parameter: Type: parametri opzionali accettati dal metodo.
• Re­turn­Ty­pe: il tipo di dati che determina il valore re­sti­tui­to dal metodo. Se il metodo non re­sti­tui­sce nessun valore, puoi indicare void.

Per accedere a una proprietà o per ri­chia­ma­re 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 re­sti­tuir­lo. Accede ai valori delle proprietà firstName e lastName, che sono stati definiti nella classe e ini­zia­liz­za­ti nel co­strut­to­re. L’oggetto person è creato per mezzo della parola chiave new seguita dal nome della classe e dai ri­spet­ti­vi parametri. Il metodo concatena le due catene di caratteri una volta ri­chia­ma­to e re­sti­tui­sce il nome completo sotto forma di stringa. L’output per l’oggetto person è quindi “John Doe”.

Esempi di ap­pli­ca­zio­ne delle classi di Ty­pe­Script

Le classi di Ty­pe­Script di­spon­go­no di diversi mec­ca­ni­smi per or­ga­niz­za­re e con­trol­la­re la struttura e il com­por­ta­men­to degli oggetti. Nelle parti seguenti ti mostriamo alcuni concetti per l’utilizzo delle classi di Ty­pe­Script.

Vi­si­bi­li­tà

La vi­si­bi­li­tà nelle classi di Ty­pe­Script regola l’accesso alle proprietà e ai metodi all’interno e all’esterno della classe. Ty­pe­Script offre tre mo­di­fi­ca­to­ri della vi­si­bi­li­tà: public, private e protected.

• public (standard): le proprietà e i metodi ca­rat­te­riz­za­ti da public possono essere ri­chia­ma­ti da ogni posizione, sia all’interno che all’esterno della classe.

• private: private si riferisce a proprietà e metodi che possono essere ri­chia­ma­ti solo all’interno della classe stessa. Sono inac­ces­si­bi­li per le parti di codice esterne.

• protected: le proprietà e i metodi ca­rat­te­riz­za­ti da protected possono essere ri­chia­ma­ti dalla classe stessa e da classi derivate (nell’ere­di­ta­rie­tà), 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 ri­chia­ma­re il metodo greet dall’esterno.

Ere­di­ta­rie­tà

L’ere­di­ta­rie­tà è un concetto fon­da­men­ta­le della pro­gram­ma­zio­ne orientata agli oggetti (OOP), uti­liz­za­ta in Ty­pe­Script e in molti altri linguaggi di pro­gram­ma­zio­ne web. Permette la creazione di una nuova classe partendo da una classe base o da una su­per­clas­se già esistenti. La classe derivata (sot­to­clas­se) eredita quindi le proprietà e i metodi della classe base e può espan­der­li 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 so­vra­scri­ve il metodo makeSound per ag­giun­ge­re un com­por­ta­men­to specifico mentre ac­qui­si­sce la proprietà name da Animal.

Readonly

La parola chiave readonly è uti­liz­za­bi­le per di­chia­ra­re come protette da scrittura le proprietà delle classi di Ty­pe­Script o degli oggetti. In pratica non è più possibile cambiare il valore di una proprietà protetta da scrittura dopo la sua ini­zia­liz­za­zio­ne.

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 è ini­zia­liz­za­ta nel co­strut­to­re. Dopo l’ini­zia­liz­za­zio­ne non è più possibile cambiare pi. Tentando di mo­di­fi­ca­re il valore di pi dopo l’ini­zia­liz­za­zio­ne, Ty­pe­Script genera un errore di com­pi­la­zio­ne.