Felflöden och beroenden
Spåra typade fel och injicerade beroenden i effekter.
Felflöden och beroenden är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 4 av 4. 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 4 lektioner.
Felkanaler och beroenden
Två kanaler gör Effect kraftfullt: den typade felkanalen (E) och kravkanalen (R). I den här lektionen får du se hur du misslyckas med typade fel och hur du tillhandahåller beroenden via Context och Layer.
Typade fel med Effect.fail
Effect.fail placerar ett värde i felkanalen. Taggade klasser gör det enkelt att skilja mellan olika fel.
import { Effect } from "effect";
class NotFound { readonly _tag = "NotFound"; }
class Forbidden { readonly _tag = "Forbidden"; }
const load = Effect.fail(new NotFound());
// Effect<never, NotFound, never>Fel bildar unioner när du komponerar
När du sekvenserar effekter med olika fel bildar felen en union i E-kanalen, så typen listar alla möjliga fel.
// Effect<A, NotFound, never> then Effect<B, Forbidden, never>
// => Effect<B, NotFound | Forbidden, never>Hantera fel
Effect.catchAll eller catchTag hanterar fel och tar bort dem från kanalen (eller ersätter dem). När du hanterar NotFound blir E smalare.
import { Effect, pipe } from "effect";
const safe = pipe(
Effect.fail(new NotFound()),
Effect.catchTag("NotFound", () => Effect.succeed("default"))
);
// Effect<string, never, never> -- error handledÅterställning jämfört med vidarebefordran
Om du inte hanterar ett fel ligger det kvar i E och vidarebefordras till anroparen, som sedan måste hantera eller vidarebefordra det. Kompilatorn ser till att fel aldrig försvinner obemärkt.
Deklarera ett beroende
En tjänst deklareras som en Context.Tag. Effekter som använder den får tjänsten i sin R-kanal.
import { Context, Effect } from "effect";
class Random extends Context.Tag("Random")<
Random,
{ readonly next: Effect.Effect<number> }
>() {}
const program = Effect.gen(function* () {
const random = yield* Random;
return yield* random.next;
});
// Effect<number, never, Random>Kraven syns i typen
Lägg märke till att R-kanalen nu innehåller Random. Effekten kan inte köras förrän kravet har uppfyllts; kompilatorn tvingar fram detta.
Tillhandahåll med ett lager
En Layer beskriver hur en tjänst ska byggas. När du tillhandahåller ett lager uppfylls kravet och tas bort från R.
import { Effect, Layer } from "effect";
const RandomLive = Layer.succeed(Random, {
next: Effect.sync(() => Math.random()),
});
const runnable = Effect.provide(program, RandomLive);
// Effect<number, never, never> -- R clearedLager kan komponeras
Lager kan bero på andra lager och slås ihop för att bygga en fullständig beroendegraf. Effect kopplar ihop dem i rätt ordning utifrån deras typer.
import { Layer } from "effect";
// Layer.merge(DatabaseLive, LoggerLive)
// Layer that provides both servicesTesta genom att byta lager
Eftersom beroenden är explicita kan tester tillhandahålla ett annat lager (till exempel en deterministisk Random) utan att ändra programmet som testas. Det är en stor fördel med att spåra krav.
import { Layer, Effect } from "effect";
const RandomTest = Layer.succeed(Random, {
next: Effect.succeed(0.5),
});
// Effect.provide(program, RandomTest) -> deterministicVarför detta är viktigt
Fel- och kravkanalerna omvandlar osynliga antaganden till kompilatorkontrollerade kontrakt: varje fel måste hanteras eller deklareras, och varje beroende måste tillhandahållas. Det är detta som gör stora Effect-program robusta och lätta att testa.
Snabb kontroll
Bekräfta att du har förstått felkanaler och beroenden.
Sammanfattning
Felkanalen spårar typade fel (Effect.fail, som begränsas av catchTag/catchAll) och bildar unioner när du komponerar. Kravkanalen spårar tjänster som deklareras via Context.Tag och uppfylls av Layer-objekt genom Effect.provide. Tillsammans gör de fel och beroenden kompilatorkontrollerade och tester enkla genom att du kan byta lager.
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 ”Felflöden och beroenden” gratis?
Ja – hela texten till ”Felflöden och beroenden” 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 4 lektioner.
Vad lär jag mig i ”Felflöden och beroenden”?
Spåra typade fel och injicerade beroenden i effekter. 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 4 av 4.
Hur lång tid tar lektionen ”Felflöden och beroenden”?
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
- Varför effektsystem är viktiga
- Effekttypen
- Komponera effekter
- Felflöden och beroenden