Generieke interfaces en type-aliassen
Definieer generieke interfaces en type-aliassen; voeg beperkingen en standaardwaarden toe en begrijp waar elk type het best tot zijn recht komt.
Generieke interfaces en type-aliassen is een gratis TypeScript Academy-les op CoddyKit. Dit is les 1 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 3 lessen.
Introductie
Doel: Maak herbruikbare structuren met generieke interfaces en type-aliasen. Je voegt beperkingen en standaardwaarden toe en leert de belangrijkste verschillen.
Overzicht van de les
Doel: pas gestructureerde concurrency toe met coroutineScope, begrijp propagatie van uitzonderingen en gebruik hulpmiddelen voor annulering veilig.
Belangrijkste ideeën
- coroutineScope wacht op alle kinderen; bij een fout worden zuster-coroutines geannuleerd.
- launch faalt onmiddellijk binnen het bereik; async maakt fouten zichtbaar bij await().
- withTimeout annuleert werk na een limiet.
- Omring bereiken met try/catch om uitzonderingen af te handelen.
Generieke interface
Een generieke interface bevat een typeparameter. Aanroepers vullen concrete typen in, bijvoorbeeld 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);Generiek type-alias
Een type-alias kan ook generiek zijn en objecten, functies, unies of doorsneden uitdrukken.
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);Wachtgedrag van het bereik
coroutineScope maakt een kindbereik dat pas wordt voltooid nadat zijn kinderen zijn afgerond.
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")
}Een fout annuleert zuster-coroutines
Als één kind een uitzondering gooit, annuleert het bereik zuster-coroutines en gooit het de uitzondering opnieuw naar de aanroeper; gebruik try/catch op de aanroepplek.
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")
}Beperkingen
Voeg een beperking met extends toe zodat T de vereiste leden, zoals id, beschikbaar maakt voor de interfacemethoden.
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));Fouten bij async en await
Uitzonderingen van async ontstaan wanneer je await() aanroept; handel ze af met 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")
}Standaardwaarden en uitbreiding
Geef standaardtypeparameters voor gebruiksgemak en bouw met hulpmiddelen voort op typen, bijvoorbeeld 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: readonlyAnnulering met withTimeout
Gebruik withTimeout om werk te begrenzen; het annuleert het kind en gooit 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")
}
}Verschillen in samenvoegen
Interfaces ondersteunen het samenvoegen van declaraties. Type-aliasen kunnen niet worden samengevoegd; dubbele namen zijn fouten.
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)Foutregel voor gestructureerde concurrency
Controle van interfaces en typen
Korte controle: Welke uitspraak over generieke interfaces en type-aliasen is WAAR?
Samenvatting
Samenvatting: Gebruik generieke interfaces en type-aliasen om herbruikbare structuren te modelleren. Voeg beperkingen en standaardwaarden toe en onthoud: alleen interfaces kunnen worden samengevoegd.
Samenvatting
Samenvatting: gebruik coroutineScope om werk te groeperen; een falend kind annuleert zuster-coroutines. Handel fouten af met try/catch, maak async-fouten zichtbaar bij await() en annuleer lange taken met withTimeout.
Leer TypeScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 101
- Lessen
- 352
Veelgestelde vragen
Is de les “Generieke interfaces en type-aliassen” gratis?
Ja — de volledige tekst van “Generieke interfaces en type-aliassen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 3 lessen.
Wat leer ik in “Generieke interfaces en type-aliassen”?
Definieer generieke interfaces en type-aliassen; voeg beperkingen en standaardwaarden toe en begrijp waar elk type het best tot zijn recht komt. Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met TypeScript Academy te beginnen?
Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.
Hoe lang duurt de les “Generieke interfaces en type-aliassen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?
Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Generieke interfaces en type-aliassen
- Conditionele typen (introductie) en distributie over unions
- Herbruikbare patronen voor datamodellen