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à

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

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

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

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