PricingLoginStart free
Kotlin Academy · Lektion

Either<L, R>: Typesikker fejlhåndtering uden exceptions

Brug Either til at repræsentere succes og fejl uden at kaste exceptions

Lektion 1 af 413 trin

Either<L, R>: Typesikker fejlhåndtering uden exceptions er en gratis Kotlin Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Kotlin Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Problemet ved undtagelser i forretningslogik

Undtagelser er beregnet til uventede fejl (null-pointer, IO-fejl). Hvis du bruger dem til at signalere forventede forretningsfejl (valideringsfejl, "ikke fundet"), bliver kontrolflowet usynligt, du tvinges til at bruge try/catch ved hvert kald, og fejl skjules i funktionssignaturerne.

Hvad er Either<L, R>?

Either er en sumtype med to tilfælde: Left(value: L) indeholder konventionelt fejlen, mens Right(value: R) indeholder succesværdien. En funktion, der returnerer Either, gør muligheden for fejl eksplicit i sin signatur.

Arrows Either

Føj Arrow til dit projekt for at få Either og hele dets økosystem af operatorer:

// build.gradle.kts
implementation("io.arrow-kt:arrow-core:1.2.4")

// Usage
import arrow.core.Either
import arrow.core.left
import arrow.core.right

Returnering af Either fra en funktion

Returnér value.right() ved succes og error.left() ved fejl. Den kaldende kode skal håndtere begge grene:

sealed class UserError { object NotFound : UserError(); data class InvalidEmail(val msg: String) : UserError() }

fun findUser(id: Long): Either<UserError, User> =
    if (id <= 0) UserError.NotFound.left()
    else User(id, "Alice").right()

Håndtering af Either med fold

Brug fold(ifLeft, ifRight) til at håndtere begge tilfælde i ét udtryk:

val result = findUser(1L)
val message = result.fold(
    ifLeft  = { error -> "Error: $error" },
    ifRight = { user  -> "Found: ${user.name}" }
)
println(message)

Transformation af Right-værdien med map

map { } transformerer Right-værdien uden at påvirke en Left. Det gør Either til en funktor — du kan kæde transformationer sikkert sammen:

val nameResult: Either<UserError, String> = findUser(1L).map { it.name }

Kædning med flatMap

flatMap { } kæder beregninger, der selv returnerer Either. Hvis et trin returnerer Left, afbrydes kæden, og fejlen føres videre uden at udføre de efterfølgende trin:

fun validateEmail(email: String): Either<UserError, String> =
    if (email.contains("@")) email.right()
    else UserError.InvalidEmail("bad format").left()

fun createUser(email: String): Either<UserError, User> =
    validateEmail(email).flatMap { validEmail ->
        User(1L, validEmail).right()
    }

Indpakning af undtagelser med Either.catch

Either.catch { } kører en blok og pakker enhver undtagelse ind som en Left. Brug den ved grænsen mellem ældre kode, der kaster undtagelser, og dit Either-baserede domæne:

val result: Either<Throwable, User> = Either.catch {
    userRepository.findOrThrow(id)
}

Genoprettelse med getOrElse og orElse

getOrElse { default } henter Right-værdien eller returnerer en standardværdi. orElse { alternativeEither } erstatter en Left med en anden beregning:

val user: User = findUser(0L).getOrElse { User(-1L, "Guest") }
val user2: Either<UserError, User> = findUser(0L).orElse { User(99L, "Default").right() }

Mønstermatchning med when

Brug when på en sealed Either-lignende klasse eller på selve Either med is Either.Left / Either.Right for at håndtere alle tilfælde udtømmende:

when (val r = findUser(1L)) {
    is Either.Left  -> println("Error: ${r.value}")
    is Either.Right -> println("User: ${r.value.name}")
}

Either i servicelag

Returnér Either fra repository- og servicefunktioner. Omdan det til HTTP-svar på Ktor-ruteniveau, så forretningslogikken holdes fri for rammeværksspecifikke hensyn:

get("/users/{id}") {
    val id = call.parameters["id"]?.toLongOrNull() ?: return@get call.respond(HttpStatusCode.BadRequest)
    userService.findById(id).fold(
        ifLeft  = { call.respond(HttpStatusCode.NotFound) },
        ifRight = { call.respond(it) }
    )
}

Hurtigt tjek

Hvad gør flatMap { } på en Either.Left-værdi?

Besvar den i den interaktive lektion

Opsummering: Either<L, R>

Vigtigste pointer:

  • Either gør fejlstien eksplicit i funktionssignaturen
  • Right = succes; Left = fejl (konventionelt)
  • map { } — transformerer succesværdien; flatMap { } — kæder fejlbartende beregninger sammen
  • fold(ifLeft, ifRight) — håndterer begge tilfælde i ét udtryk
  • Either.catch { } — pakker kode, der kaster undtagelser, ind ved grænserne
Gratis at komme i gang

Lær Kotlin med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
51
Lektioner
203
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Either<L, R>: Typesikker fejlhåndtering uden exceptions” gratis?

Ja — alle 3 lektioner i læringssporet Kotlin Academy, inklusive “Either<L, R>: Typesikker fejlhåndtering uden exceptions”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Kotlin Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Either<L, R>: Typesikker fejlhåndtering uden exceptions”?

Brug Either til at repræsentere succes og fejl uden at kaste exceptions Du øver dig i Kotlin Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Kotlin Academy?

Der kræves ingen tidligere erfaring. Kotlin Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Either<L, R>: Typesikker fejlhåndtering uden exceptions”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Kotlin Academy-lektion?

Ja. Alle Kotlin Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Either : Typesikker fejlhåndtering uden exceptions
  2. Arrow Raise DSL: Sammensætning af typede fejl
  3. Option og nullable: Hvornår skal de bruges
  4. Funktionel domænemodellering med Arrows kernetyper
← Tilbage til Kotlin Academy