Come lavora il compilatore con le classi
Come lavora il compilatore con le classi
Nella prima lezione avete visto che tsc controlla i tipi e poi li toglie: quello che esce è JavaScript, senza : number e senza : string (se vi serve un ripasso, c'è Compilatore, interprete e transpiler). Con le classi la domanda si allarga. private, protected, abstract, interface, implements: che fine fanno? Restano nel JavaScript, oppure spariscono come i tipi?
In breve: le classi restano, quasi tutto il resto sparisce. Sotto c'è l'output vero di tsc.
Un esempio piccolo
Un'interfaccia, una classe astratta con una proprietà private e una protected readonly, e una figlia:
interface Descrivibile {
descrivi(): string;
}
abstract class Strumento implements Descrivibile {
protected readonly nome: string;
private accordato: boolean = false;
constructor(nome: string) {
this.nome = nome;
}
accorda(): void {
this.accordato = true;
}
abstract suona(): string;
descrivi(): string {
const stato: string = this.accordato ? "accordato" : "da accordare";
return `${this.nome} (${stato})`;
}
}
class Chitarra extends Strumento {
private corde: number;
constructor(corde: number) {
super("chitarra");
this.corde = corde;
}
suona(): string {
return `Accordo di Mi su ${this.corde} corde`;
}
}
const s: Strumento = new Chitarra(6);
s.accorda();
console.log(s.descrivi()); // chitarra (accordato)
console.log(s.suona()); // Accordo di Mi su 6 corde
Lo compiliamo con tsc --strict --target ES2022 strumenti.ts. Il target dice a tsc per quale versione di JavaScript scrivere: ES2022 è una versione del 2022, che capiscono tutti i browser e le versioni di Node.js di oggi. Questo è il file strumenti.js che esce, copiato così com'è:
"use strict";
class Strumento {
nome;
accordato = false;
constructor(nome) {
this.nome = nome;
}
accorda() {
this.accordato = true;
}
descrivi() {
const stato = this.accordato ? "accordato" : "da accordare";
return `${this.nome} (${stato})`;
}
}
class Chitarra extends Strumento {
corde;
constructor(corde) {
super("chitarra");
this.corde = corde;
}
suona() {
return `Accordo di Mi su ${this.corde} corde`;
}
}
const s = new Chitarra(6);
s.accorda();
console.log(s.descrivi());
console.log(s.suona());
Mettete i due file uno accanto all'altro e cercate le differenze. "use strict" in cima è una riga che tsc aggiunge con l'opzione --strict: chiede a JavaScript di segnalare alcuni errori che altrimenti lascerebbe passare.
Cosa resta e cosa sparisce
| Nel TypeScript | Nel JavaScript | Perché |
|---|---|---|
interface Descrivibile { ... } |
Sparisce del tutto | È solo un contratto per il compilatore: non c'è codice da eseguire |
implements Descrivibile |
Sparisce | Il controllo è già stato fatto |
class, extends, constructor, super(...) |
Restano uguali | JavaScript ha le classi dal 2015 |
abstract class Strumento |
class Strumento |
abstract sparisce, la classe resta |
abstract suona(): string; |
Sparisce | Non ha corpo, quindi non c'è niente da scrivere |
private, protected, readonly |
Spariscono | Sono controlli del compilatore |
: string, : number, : boolean, : void |
Spariscono | Come tutti i tipi |
nome; e accordato = false; |
Restano, senza tipo | Sono la dichiarazione delle proprietà, che JavaScript conosce |
| Metodi con il corpo | Restano, senza tipi | Sono il codice da eseguire |
Una regola che riassume la tabella: resta quello che serve mentre il programma gira, sparisce quello che serve solo al controllo. Il JavaScript prodotto non sa niente di contratti, di metodi da implementare o di chi può leggere cosa. Tutto questo lo ha controllato tsc prima, e dopo il controllo non serve più.
La scorciatoia del costruttore
C'è un caso in cui tsc non si limita a togliere, ma aggiunge codice. Sono i parametri del costruttore con private, public o readonly davanti, la scorciatoia della lezione precedente:
class Tessera {
constructor(
readonly numero: number,
private prestitiAttivi: number,
) {}
}
"use strict";
class Tessera {
numero;
prestitiAttivi;
constructor(numero, prestitiAttivi) {
this.numero = numero;
this.prestitiAttivi = prestitiAttivi;
}
}
Il costruttore vuoto si è riempito con le due assegnazioni che avreste scritto a mano. readonly e private sono spariti, come sempre, ma prima tsc li ha usati per capire che quei parametri dovevano diventare proprietà.
Le interfacce non esistono mentre il programma gira
Siccome l'interfaccia sparisce, nel programma che gira non c'è niente che si chiami Descrivibile. Per questo non potete chiedere a un oggetto se la implementa:
interface Descrivibile {
descrivi(): string;
}
class Quadro {
descrivi(): string {
return "un quadro";
}
}
const q: Quadro = new Quadro();
if (q instanceof Descrivibile) { // errore: 'Descrivibile' only refers to a type, but is being used as a value here.
console.log("descrivibile");
}
Il messaggio dice proprio questo: Descrivibile è solo un tipo, e voi lo state usando come un valore, cioè come una cosa che esiste mentre il programma gira. Con una classe, anche astratta, instanceof funziona, perché la classe nel JavaScript c'è ancora.
abstract è solo un controllo
Nel JavaScript Strumento è una classe normale. Se qualcuno la usasse da un file JavaScript, senza passare da tsc, potrebbe crearne un'istanza:
const triangolo = new Strumento("triangolo");
console.log(triangolo); // Strumento { nome: 'triangolo', accordato: false }
console.log(triangolo.suona()); // TypeError: triangolo.suona is not a function
Nessuno lo ferma alla new. L'errore arriva solo quando si chiama il metodo che mancava, mentre il programma gira. È il tipo di errore che tsc vi risparmia: con abstract, lo stesso new Strumento(...) in TypeScript si ferma prima di partire con Cannot create an instance of an abstract class.
private resta solo un controllo del compilatore
Lo stesso vale per private. Nel JavaScript accordato è una proprietà come le altre, e chiunque la può leggere e scrivere. Si vede anche senza uscire da TypeScript:
class Account {
private password: string = "Treno-1987";
}
const a = new Account();
console.log(a); // Account { password: 'Treno-1987' }
console.log(a["password"]); // Treno-1987
a.password sarebbe un errore (Property 'password' is private and only accessible within class 'Account'.). Ma console.log(a) stampa l'istanza intera, password compresa. E la forma con le quadre, a["password"], il compilatore la lascia passare apposta, come via d'uscita per chi sa quello che fa.
Quindi private vi protegge dagli errori: se scrivete a.password per sbaglio, il compilatore vi ferma. Non protegge da chi vuole leggere il dato a tutti i costi. Per una password non basta, e in ogni caso un segreto vero non deve stare in un programma che gira sul computer di qualcun altro.
I campi #privati di JavaScript
JavaScript, dal 2022, ha un suo modo di fare una proprietà privata: il nome comincia con il cancelletto, #. Questo non è un controllo del compilatore. È il motore JavaScript stesso che non lascia passare nessuno.
class Account {
#password: string = "Treno-1987";
controlla(tentativo: string): boolean {
return tentativo === this.#password;
}
}
const a = new Account();
console.log(a.controlla("1234")); // false
console.log(a.controlla("Treno-1987")); // true
console.log(a); // Account {}
console.log(a.#password); // errore: Property '#password' is not accessible outside class 'Account' because it has a private identifier.
E il JavaScript prodotto con il target ES2022:
"use strict";
class Account {
#password = "Treno-1987";
controlla(tentativo) {
return tentativo === this.#password;
}
}
const a = new Account();
console.log(a.controlla("1234"));
console.log(a.controlla("Treno-1987"));
console.log(a);
(Il file compilato è quello senza l'ultima riga, quella con l'errore.) Questa volta il # resta: fa parte di JavaScript, non di TypeScript. Le differenze con private:
private password |
#password |
|
|---|---|---|
| Chi lo controlla | Solo tsc, prima di partire |
Anche il motore JavaScript, mentre il programma gira |
| Nel JavaScript prodotto | Sparisce, resta password normale |
Resta #password |
console.log(a) |
Mostra la proprietà | Non la mostra (Account {}) |
Da fuori con a["..."] |
Si legge | Non si legge |
a.#password scritto fuori dalla classe in un file JavaScript |
Il programma non parte nemmeno: SyntaxError: Private field '#password' must be declared in an enclosing class |
Se il target fosse una versione più vecchia di JavaScript, che non conosce il #, tsc tradurrebbe il campo in codice più lungo che fa la stessa cosa con altri mezzi (una WeakMap e qualche funzione di appoggio). Qui tsc non si limita a togliere: riscrive.
Nel corso usiamo private: si legge meglio, e per gli errori che fate voi protegge allo stesso modo. Nel codice degli altri troverete tutti e due.
Perché TypeScript è fatto così
TypeScript ha una regola di fondo: il JavaScript prodotto deve essere quello che avreste scritto a mano, solo senza i tipi. Per questo restano uguali le cose che JavaScript conosce (classi, extends, super, #) e spariscono le altre (interfacce, abstract, private, protected, readonly, i tipi).
La conseguenza: un errore di tipo si vede solo quando compilate. Mentre il programma gira TypeScript non c'è più, c'è solo JavaScript.