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.