Generiska interfaces och typalias
Definiera generiska interfaces och typalias, lägg till begränsningar och standardvärden och förstå när respektive variant är bäst lämpad.
Generiska interfaces och typalias är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 1 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 3 lektioner.
Introduktion
Mål: Skapa återanvändbara strukturer med generiska gränssnitt och typalias. Ni kommer att lägga till begränsningar och standardvärden samt lära er viktiga skillnader.
Översikt av lektionen
Mål: Tillämpa strukturerad samtidighet med coroutineScope, förstå spridning av undantag och använda verktyg för avbrytning på ett säkert sätt.
Huvudidéer
- coroutineScope väntar på alla underordnade korutiner; ett fel avbryter syskonen.
- launch misslyckas omedelbart i scopet; async visar fel när await() anropas.
- withTimeout avbryter arbetet efter en tidsgräns.
- Omge scope med try/catch för att hantera undantag.
Generiskt gränssnitt
Ett generiskt gränssnitt innehåller en typparameter. Anroparna ersätter den med konkreta typer (till exempel 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);Generiskt typalias
Ett typalias kan också vara generiskt och uttrycka objekt, funktioner, unioner eller snitt.
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);Beteende vid väntan i scope
coroutineScope skapar ett underordnat scope som slutförs först när dess underordnade korutiner har avslutats.
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")
}Ett fel avbryter syskon
Om en underordnad korutin kastar ett undantag avbryter scope syskonen och kastar om undantaget till anroparen. Använd try/catch på anropsplatsen.
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")
}Begränsningar
Lägg till en extends-begränsning så att T exponerar de medlemmar som gränssnittets metoder kräver (till exempel id).
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));Fel med async + await
Undantag från async uppstår när ni anropar await(). Hantera dem med 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")
}Standardvärden och utökning
Ange standardtypparametrar för smidigare användning och bygg vidare på typer med verktyg (till exempel 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: readonlyAvbrytning med withTimeout
Använd withTimeout för att begränsa arbetet i tid. Den avbryter den underordnade korutinen och kastar 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")
}
}Skillnader vid sammanslagning
Gränssnitt stöder declaration merging. Typalias kan inte slås samman; dubbla namn ger fel.
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)Regel för fel i strukturerad samtidighet
Kontroll av gränssnitt kontra typer
Snabbkontroll: Vilket påstående om generiska gränssnitt och typalias är SANT?
Sammanfattning
Sammanfattning: Använd generiska gränssnitt och typalias för att modellera återanvändbara strukturer. Lägg till begränsningar och standardvärden och kom ihåg: endast gränssnitt kan slås samman.
Sammanfattning
Sammanfattning: Använd coroutineScope för att gruppera arbete; en korutin som misslyckas avbryter syskonen. Hantera fel med try/catch, visa fel från async vid await() och avbryt långvariga uppgifter med withTimeout.
Lär dig TypeScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 101
- Lektioner
- 352
Vanliga frågor
Är lektionen ”Generiska interfaces och typalias” gratis?
Ja – hela texten till ”Generiska interfaces och typalias” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 3 lektioner.
Vad lär jag mig i ”Generiska interfaces och typalias”?
Definiera generiska interfaces och typalias, lägg till begränsningar och standardvärden och förstå när respektive variant är bäst lämpad. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?
Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 3.
Hur lång tid tar lektionen ”Generiska interfaces och typalias”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?
Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Generiska interfaces och typalias
- Villkorstyper (introduktion) och distribution över unioner
- Återanvändbara mönster för datamodeller