Le novità di TypeScript 4.3

di Morgan Pizzini,

Typescript è da alcuni anni un linguaggio molto affermato sulla scena web sia per quanto riguarda il frontend che per il backend. Durante gli anni ha ricevuto importanti aggiornamenti e con la versione 4.3 le caratteristiche di type-checking sono state ulteriormente affinate.

Differenziare getter e setter per una proprietà



Nel JavaScript, un linguaggio non tipizzato, per essere sicuri della tipologia di una proprietà abbiamo bisogno di creare dei setter ad-hoc.

class Persona {
    #eta = 0;

    get eta() {
        return this.#eta;
    }
    set eta(value) {
        let num = Number(value);
        if (!Number.isFinite(num)) {
            this.#eta = 0;
            return;
        }
        this.#eta = num;
    }
}

Le stesse operazioni possono essere compiute in TypeScript, ma nel momento in cui vogliamo introdurre una tipizzazione troviamo molte restrizioni: fino ad ora il getter e il setter dovevano avere lo stesso tipo in input e output, rendendo quindi necessario molteplici funzioni per gestire la valorizzazione di una proprietà tramite una string, number un boolean ecc... Per convertire restando il più fedeli possibili all'esempio precedente, avremmo dovuto utilizzare il tipo unknown o any, perdendo però tutti i vantaggi offerti dal linguaggio. Con la versione 4.3 è ora possibile differenziare la tipologia di ingresso dei metodi get e set.

class Persona {
    #eta = 0;

    get eta(): number {
            return eta;
    }
    set eta(value: string | number | boolean) {
        //...
    }
}

L'unica limitazione sta nell'avere una tipologia in comune tra get e set, in modo che la variabile possa essere riassegnata a sé stessa.

Una nuova keyword: override



Partiamo sempre dall'esempio JavaScript per poter comprendere le vere potenzialità del TypeScript. Creiamo una classe base e una derivata che ne sovrascrive un metodo esistente.

class BaseClass {
    metodo() {
        // ...
    }
}

class ExtClass extends BaseClass {
    metodo() {
        // ...
    }
}

Nel caso in cui il metodo nella classe base venisse eliminato, non verrebbe mostrato alcun errore, e ci troveremo con la classe derivata con un metodo che non dovrebbe esistere. Per forzare questo check possiamo utilizzare la keyword override.

class BaseClass {
    // metodo() {
        // ...
    // }
    altroMetodo(){}
}

class ExtClass extends BaseClass {
    override metodo() {
        // ...
    }
}

In questo caso, nel momento in cui il metodo nella classe base venisse rimosso, troveremo un errore di compilazione.

Oltre alla keyword, nella versione 4.3 è possibile settare i Linter Checks del compilatore con l'argomento --noImplicitOverride, il quale consente, come nel caso del primo esempio, di emettere un errore quando si effettua la sovrascrittura di un metodo senza utilizzare override: senza questa accortezza non avremmo alcun errore se il metodo nella classe base venisse rimosso.

Proprietà private



Benché in TypeScript vi sia una differenziazione tra pubblico e privato, è in realtà possibile chiamare a runtime una proprietà private a causa della natura di JavaScript. A seguito degli ultimi aggiornamenti a ECMAScript, possiamo definire una proprietà o un metodo come private utilizzando la keyword #private. Con Typescript 4.3 è possibile definire metodi e proprietà con la stessa metodologia.

class Persona {
    #eta: number;
    
    #seteta(): number {}

    static #getDescription(){}
}
// errori
let p = new Persona().#seteta(1);
let e = new Persona().#eta;
let d = Persona().#getDescription();

Commenti

Visualizza/aggiungi commenti

| Condividi su: Twitter, Facebook, LinkedIn

Per inserire un commento, devi avere un account.

Fai il login e torna a questa pagina, oppure registrati alla nostra community.

Approfondimenti

I più letti di oggi