Interfacce generiche e alias di tipo
Definisca interfacce generiche e alias di tipo; aggiunga vincoli e valori predefiniti e comprenda i punti di forza di ciascuno.
Interfacce generiche e alias di tipo è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 3 lezioni in totale.
Introduzione
Obiettivo: creare strutture riutilizzabili usando interfacce generiche e alias di tipo. Aggiungerà vincoli e valori predefiniti e imparerà le differenze principali.
Panoramica della lezione
Obiettivo: applicare la concorrenza strutturata con coroutineScope, comprendere la propagazione delle eccezioni e usare in sicurezza gli strumenti di cancellazione.
Concetti chiave
- coroutineScope attende tutti i figli; un errore annulla i fratelli.
- launch fallisce immediatamente nello scope; async rende visibili gli errori su await().
- withTimeout annulla il lavoro dopo un limite.
- Racchiuda gli scope in try/catch per gestire le eccezioni.
Interfaccia generica
Un'interfaccia generica contiene un parametro di tipo. Chi la utilizza sostituisce tipi concreti (ad esempio Box<number>).
interface Box<T> {
value: T;
}
const nBox: Box<number> = { value: 42 };
const sBox: Box<string> = { value: "ts" };
console.log(nBox.value, sBox.value);Alias di tipo generico
Un alias di tipo può essere generico ed esprimere anche oggetti, funzioni, unioni o intersezioni.
type Pair<A, B> = { first: A; second: B };
const p1: Pair<number, string> = { first: 1, second: "one" };
const p2: Pair<boolean, boolean> = { first: true, second: false };
console.log(p1, p2);Comportamento di attesa dello scope
coroutineScope crea uno scope figlio che termina solo dopo che tutti i suoi figli hanno terminato.
import kotlinx.coroutines.*
suspend fun doTwoTasks(): Unit = coroutineScope {
// Both run concurrently and the scope waits for them
launch { delay(150); println("Task A done") }
launch { delay(100); println("Task B done") }
// returning Unit implicitly after children complete
}
fun main() = runBlocking {
doTwoTasks()
println("Scope completed")
}Un errore annulla i fratelli
Se un figlio genera un'eccezione, lo scope annulla i fratelli e rilancia l'eccezione al chiamante; usi try/catch nel punto di chiamata.
import kotlinx.coroutines.*
suspend fun failingGroup() = coroutineScope {
val a = launch {
try {
repeat(5) { i ->
println("A $i"); delay(60)
}
} finally {
println("A cancelled")
}
}
launch {
delay(120)
throw IllegalStateException("boom") // failure in child
}
a.join() // will be cancelled when sibling fails
}
fun main() = runBlocking {
try {
failingGroup()
} catch (e: Exception) {
println("Caught in caller: ${e.message}")
}
println("Caller continues")
}Vincoli
Aggiunga un vincolo extends affinché T esponga i membri richiesti (ad esempio id) ai metodi dell'interfaccia.
interface Repository<T extends { id: number }> {
getById(id: number): T | undefined;
save(entity: T): void;
}
type User = { id: number; name: string };
const memRepo: Repository<User> = {
store: [] as User[],
getById(id) {
return this.store.find(u => u.id === id);
},
save(u) {
this.store.push(u);
}
} as unknown as Repository<User>;
memRepo.save({ id: 1, name: "Ada" });
console.log(memRepo.getById(1));Errori di async + await
Le eccezioni di async vengono sollevate quando chiama await(); le gestisca con try/catch.
import kotlinx.coroutines.*
suspend fun parseAsync(s: String) = coroutineScope {
val deferred = async {
delay(50)
s.toInt() // may throw NumberFormatException
}
try {
println("Result = ${deferred.await()}") // error appears here
} catch (e: NumberFormatException) {
println("Handled parse error: ${e::class.simpleName}")
}
}
fun main() = runBlocking {
parseAsync("12")
parseAsync("xx")
}Valori predefiniti ed estensione
Fornisca parametri di tipo predefiniti per una maggiore praticità e costruisca sui tipi con le utility (ad esempio Readonly<Box<T>>).
interface ApiResponse<T = unknown> {
data: T;
ok: boolean;
}
type ReadonlyBox<T> = Readonly<Box<T>>;
const r1: ApiResponse = { data: "ok", ok: true }; // T defaults to unknown
const r2: ApiResponse<number> = { data: 200, ok: true };
const rb: ReadonlyBox<string> = { value: "fixed" };
// rb.value = "change"; // Error: readonlyCancellazione con withTimeout
Usi withTimeout per limitare la durata del lavoro; annulla il figlio e genera TimeoutCancellationException.
import kotlinx.coroutines.*
suspend fun slowOp(): Int {
delay(300) // pretend work
return 42
}
fun main() = runBlocking {
try {
val result = withTimeout(150) { slowOp() } // cancels after 150ms
println("Got $result")
} catch (e: TimeoutCancellationException) {
println("Timed out and cancelled")
}
}Differenze nella fusione
Le interfacce supportano la fusione delle dichiarazioni. Gli alias di tipo non possono essere fusi; i nomi duplicati generano errori.
interface Settings { theme: string }
interface Settings { lang: string }
// Merged: Settings has { theme: string; lang: string }
const s: Settings = { theme: "dark", lang: "en" };
// type Settings = { foo: string };
// Error: Duplicate identifier 'Settings' for type aliases (no merging)Regola di fallimento della concorrenza strutturata
Verifica su interfacce e tipi
Verifica rapida: quale affermazione sulle interfacce generiche e sugli alias di tipo è VERA?
Riepilogo
Riepilogo: utilizzi interfacce generiche e alias di tipo per modellare strutture riutilizzabili. Aggiunga vincoli e valori predefiniti e ricordi: solo le interfacce possono essere fuse.
Riepilogo
Riepilogo: usi coroutineScope per raggruppare il lavoro; un figlio che fallisce annulla i fratelli. Gestisca gli errori con try/catch, renda visibili gli errori di async su await() e annulli le attività lunghe con withTimeout.
Domande Frequenti
La lezione «Interfacce generiche e alias di tipo» è gratuita?
Sì — il testo completo di «Interfacce generiche e alias di tipo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 3 lezioni in totale.
Cosa imparerò in «Interfacce generiche e alias di tipo»?
Definisca interfacce generiche e alias di tipo; aggiunga vincoli e valori predefiniti e comprenda i punti di forza di ciascuno. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare TypeScript Academy?
Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.
Quanto tempo richiede la lezione «Interfacce generiche e alias di tipo»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?
Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Interfacce generiche e alias di tipo
- Tipi condizionali (introduzione) e distribuzione sulle unioni
- Pattern riutilizzabili per i modelli di dati