Classi TypeScript: chi può accedere a ogni membro

Classi TypeScript

Classi TypeScript: modificatori, readonly, abstract, implements | We.Inc

Campi, costruttori, parameter properties, public, protected, private e #private, readonly, abstract e implements. Verifica chi può raggiungere ogni membro in una matrice live.

Una classe TypeScript è una classe JavaScript con campi tipizzati e regole di accesso. I membri public sono raggiungibili ovunque, quelli protected dentro la classe e nelle sue sottoclassi, quelli private solo dentro la classe. Questi tre controlli esistono solo in fase di compilazione. Un campo #name è privato anche nel JavaScript in esecuzione, e readonly blocca le scritture dopo il costruttore.

Le parole chiave delle classi e cosa fanno

Parola chiave
Effetto
Verificato quando

Raggiungibile da ovunque (il default)
In compilazione

Solo la classe e le sottoclassi
In compilazione

Solo la classe che lo dichiara
In compilazione

Solo la classe che lo dichiara, imposto da JavaScript
In compilazione e a runtime

Assegnabile solo nella dichiarazione o nel costruttore
In compilazione

Nessuna istanza; le sottoclassi devono implementare i membri
In compilazione

Verifica che la classe corrisponda a un'interfaccia
In compilazione

Indica un metodo che sostituisce un metodo della classe base
In compilazione

Scegli un modificatore e la matrice mostra cinque modi in cui il codice potrebbe raggiungere quel membro, con il risultato di tsc per ciascuno. La riga con le parentesi quadre è quella che sorprende: i modificatori di compilazione si possono aggirare con una chiave stringa, un campo # invece no.

Scegli un modificatore: public, protected, private, #private o readonly.
Leggi la matrice: ogni riga è un punto da cui il membro viene usato, con Compila oppure l'errore di tsc.
Guarda la classe in alto per vedere le dichiarazioni esatte sotto test.
Copia la classe per provare altri casi nel tuo editor.

Usa i campi # per tutto ciò che deve restare nascosto ad altro codice a runtime, come un token conservato da un oggetto client.
Attiva noImplicitOverride così rinominare un metodo base fa fallire ogni metodo di sottoclasse che ha smesso silenziosamente di sovrascriverlo.
Tieni attivo strictPropertyInitialization. Se un campo viene impostato da un framework dopo la costruzione, segnalo con name!: string invece di disattivare il controllo.
Prima di una classe, valuta un oggetto semplice con un'interfaccia quando non ci sono comportamento né stato privato: è meno codice e si serializza senza problemi.

Domande frequenti

Qual è la differenza tra private e #private?

private è un controllo di TypeScript. Sparisce dall'output, e obj["secret"] compila comunque e legge il valore. Un campo #secret è un campo privato JavaScript: nessuna chiave stringa lo raggiunge, e il codice fuori dalla classe non può leggerlo a runtime.

Cosa sono le parameter properties?

Una scorciatoia che dichiara e assegna un campo a partire da un parametro del costruttore. Scrivere constructor(private readonly id: string) {} crea un campo id private readonly senza bisogno di corpo. Il prefisso può essere public, protected, private o readonly.

implements cambia i tipi dentro la mia classe?

No. implements verifica solo che la classe finita rispetti l'interfaccia. I parametri dei metodi hanno comunque bisogno delle proprie annotazioni; ometterne una in strict mode genera un errore di any implicito, anche se l'interfaccia ne indica già il tipo.

Perché TypeScript dice che una proprietà non ha un inizializzatore?

strictPropertyInitialization, che strict attiva, richiede che ogni campo dichiarato sia impostato nella dichiarazione o nel costruttore. Dagli un valore, rendilo opzionale, oppure aggiungi ! dopo il nome se qualcos'altro lo imposta prima dell'uso.

Quando conviene una classe astratta invece di un'interfaccia?

Usa una classe astratta quando le sottoclassi devono condividere codice reale, come un metodo che chiama un hook astratto. Un'interfaccia non contiene codice e una classe può implementarne diverse, quindi è adatta a descrivere forme.

Campi, costruttori e parameter properties

Una dichiarazione di campo come count = 0 o name: string dice al compilatore cosa contiene l'istanza. In strict mode ogni campo deve avere un valore entro la fine del costruttore, il che intercetta il classico bug di un campo undefined al primo utilizzo.
Le parameter properties riducono a una sola riga il giro dichiara e poi assegna. Sono comode per i servizi che ricevono le dipendenze tramite il costruttore, anche se alcuni team le evitano perché producono vero codice di assegnazione invece di pura sintassi di tipo.

Privacy in compilazione contro privacy a runtime

public, protected e private vengono cancellati quando TypeScript emette JavaScript. Impediscono ai colleghi di usare male un membro nel codice tipizzato, ma qualunque cosa esegua l'output, compresa una sessione di console, può comunque leggere la proprietà.
I campi privati JavaScript con prefisso # fanno parte del linguaggio. Il motore rifiuta l'accesso dall'esterno del corpo della classe, non compaiono in Object.keys e nemmeno le sottoclassi possono vederli.

Classi e interfacce lavorano insieme

Un'interfaccia descrive una forma; una classe produce oggetti che la possiedono. Una classe può implementare più interfacce, e qualunque oggetto con i membri giusti soddisfa l'interfaccia, che ci sia di mezzo una classe o no, perché TypeScript confronta le forme e non i nomi.
La guida alle interfacce su questo sito spiega come dichiarare ed estendere quelle forme. Questa pagina riguarda il lato della classe: costruzione, accesso ed ereditarietà.

Pattern delle classi nella pratica

Parameter properties e un campo #

Il costruttore dichiara due campi nella sua lista di parametri. La cache è un campo #, quindi niente al di fuori della classe può leggerla o svuotarla.

Una base astratta con un override

describe è codice condiviso; area è l'hook che ogni forma deve fornire. Con noImplicitOverride attivo, la parola chiave override è obbligatoria su area in Circle.

implements verifica, non deduce

L'interfaccia garantisce che la classe abbia send con la forma giusta, ma il parametro ha comunque bisogno della propria annotazione di tipo.

Nessuna restrizione. Omettere il modificatore significa la stessa cosa.

Dentro i metodi di Account

Dentro un metodo di Savings

Dall'esterno, con il punto