# 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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/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. ```typescript 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: ```typescript 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: ```typescript 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: ```typescript 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. ```typescript 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. ```typescript 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. ```typescript 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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/linguaggi-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. ```typescript 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. ```typescript 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. This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/classi-di-typescript/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/classi-di-typescript/) for AI/LLM consumption.