TypeScript - Accessori

Ciao a tutti, aspiranti programmatori! Oggi esploreremo il mondo affascinante degli accessori di TypeScript. Non preoccupatevi se siete nuovi alla programmazione - vi guiderò attraverso questo argomento passo dopo passo, proprio come ho fatto per centinaia di studenti negli anni di insegnamento. Allora, prendete una tazza della vostra bevanda preferita e iniziamo!

Cos'è un Accessore?

Prima di immergerci nei dettagli degli accessori di TypeScript, capiremo cos'è un accessorie in generale. Immagina di avere una cassetta del tesoro (il nostro oggetto) e di voler controllare come le persone interagiscono con i tesori all'interno (le proprietà dell'oggetto). Gli accessori sono come le chiavi magiche che ti permettono di ottenere o impostare questi tesori in modo controllato.

In TypeScript, abbiamo due tipi di accessori:

1. Getters: Questi ci aiutano a recuperare il valore di una proprietà.
2. Setters: Questi ci permettono di impostare il valore di una proprietà.

Ora, esploriamo ciascuno di questi in dettaglio.

Getters in TypeScript

Cos'è un Getter?

Un getter è un tipo speciale di metodo che ti permette di accedere a una proprietà di un oggetto. È come avere un assistente personale che recupera informazioni per te.

Come Definire un Getter

Guardiamo un esempio semplice:

class Person {
private _name: string;

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

get name(): string {
console.log("Getting the name");
return this._name;
}
}

let person = new Person("Alice");
console.log(person.name); // Output: Getting the name \n Alice

In questo esempio:

• Abbiamo una classe Person con una proprietà privata _name.
• Definiamo un getter chiamato name utilizzando la parola chiave get.
• Quando accediamo a person.name, chiama il nostro metodo getter.

Perché Usare Getters?

1. Proprietà Calcolate: I getters possono restituire valori calcolati.

class Circle {
private _radius: number;

constructor(radius: number) {
this._radius = radius;
}

get area(): number {
return Math.PI * this._radius ** 2;
}
}

let circle = new Circle(5);
console.log(circle.area); // Output: 78.53981633974483

2. Caricamento Lazy: I getters possono aiutare con le prestazioni caricando i dati solo quando necessario.

class DataFetcher {
private _data: string | null = null;

get data(): string {
if (this._data === null) {
console.log("Fetching data...");
this._data = "Some expensive data";
}
return this._data;
}
}

let fetcher = new DataFetcher();
console.log(fetcher.data); // Output: Fetching data... \n Some expensive data
console.log(fetcher.data); // Output: Some expensive data (no fetching this time)

Setters in TypeScript

Cos'è un Setter?

Un setter è come il counterpart di un getter. È un metodo che imposta il valore di una proprietà, spesso con un po' di logica aggiuntiva.

Come Definire un Setter

Ecco un esempio di base:

class Temperature {
private _celsius: number = 0;

set celsius(value: number) {
if (value < -273.15) {
throw new Error("Temperature below absolute zero is not possible");
}
this._celsius = value;
}

get celsius(): number {
return this._celsius;
}
}

let temp = new Temperature();
temp.celsius = 25; // Questo chiama il setter
console.log(temp.celsius); // Output: 25

// temp.celsius = -300; // Questo lancerebbe un errore

In questo esempio:

• Abbiamo una classe Temperature con una proprietà privata _celsius.
• Definiamo un setter per celsius che verifica se il valore è valido prima di impostarlo.

Perché Usare Setters?

1. Validazione dei Dati: I setters possono assicurare che solo valori validi siano assegnati alle proprietà.

2. Effetti Collaterali: I setters possono innescare altre azioni quando una proprietà viene modificata.

class User {
private _name: string = "";
private _lastUpdated: Date = new Date();

set name(value: string) {
this._name = value;
this._lastUpdated = new Date();
}

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

get lastUpdated(): Date {
return this._lastUpdated;
}
}

let user = new User();
user.name = "Bob";
console.log(user.name); // Output: Bob
console.log(user.lastUpdated); // Output: Current date and time

Tabella dei Metodi Accessori

Ecco un riepilogo dei metodi accessorio che abbiamo trattato:

Tipo di Accessore	Parola Chiave	Scopo	Esempio
Getter	get	Recupera il valore di una proprietà	get name(): string { return this._name; }
Setter	set	Imposta il valore di una proprietà	set name(value: string) { this._name = value; }

Conclusione

Gli accessori in TypeScript forniscono un modo potente per controllare come le proprietà degli oggetti vengono accessibili e modificate. Permettono di aggiungere logica, validazione e proprietà calcolate alle tue classi, rendendo il codice più robusto e manutenibile.

Ricorda, come ogni nuova abilità, padroneggiare gli accessori richiede pratica. Non ti scoraggiare se non ci riesci subito - continua a programmare, continua a sperimentare, e presto sarai in grado di usare getters e setters come un professionista!

Come sempre dico ai miei studenti, programmare è come imparare una nuova lingua. All'inizio, potrebbe sembrare confusionario, ma con pazienza e pratica, presto parlerai TypeScript fluentemente. Buon divertimento con il coding, e non dimenticare di divertirti lungo il percorso!

Credits: Image by storyset