PricingLoginStart free
Kotlin Academy · leksjon

Either<L, R>: Typet feilhåndtering uten exceptions

Bruk Either til å representere suksess og feil uten å utløse unntak.

Leksjon 1 av 413 trinn

Either<L, R>: Typet feilhåndtering uten exceptions er en gratis leksjon i Kotlin Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Kotlin Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Problemet med exceptions i forretningslogikk

Exceptions er laget for uventede feil (null pointer, I/O-feil). Hvis De bruker dem til å signalisere forventede forretningsfeil (valideringsfeil, «ikke funnet»), blir kontrollflyten usynlig, De må bruke try/catch ved hvert kallested, og feil skjules i funksjonssignaturene.

Hva er Either<L, R>?

Either er en sumtype med to tilfeller: Left(value: L) inneholder konvensjonelt feilen, mens Right(value: R) konvensjonelt inneholder resultatverdien. En funksjon som returnerer Either, gjør muligheten for feil tydelig i signaturen.

Arrow sin Either

Legg til Arrow i prosjektet for å få Either og hele økosystemet av 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

Returnere Either fra en funksjon

Returner value.right() ved suksess og error.left() ved feil. Kalleren må håndtere begge grenene:

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åndtere Either med fold

Bruk fold(ifLeft, ifRight) for å håndtere begge tilfellene i ett uttrykk:

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

Transformere Right-verdien med map

map { } transformerer Right-verdien uten å påvirke en Left. Dermed blir Either en funktor — De kan lenke sammen transformasjoner på en trygg måte:

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

Lenke sammen med flatMap

flatMap { } lenker sammen beregninger som selv returnerer Either. Hvis et trinn returnerer Left, kortsluttes kjeden og feilen videreføres uten at de påfølgende trinnene kjøres:

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()
    }

Either.catch for innpakking av unntak

Either.catch { } kjører en blokk og pakker eventuelle unntak inn som en Left. Bruk den ved grensen mellom eldre kode som kaster unntak, og domenet Deres som er basert på Either:

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

Gjenopprette med getOrElse og orElse

getOrElse { default } henter ut Right-verdien eller returnerer en standardverdi. orElse { alternativeEither } erstatter en Left med en annen beregning:

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

Mønstermatching med when

Bruk when på en sealed Either-lignende klasse eller direkte på Either med is Either.Left / Either.Right for å håndtere alle tilfellene:

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

Either i servicelag

Returner Either fra repository- og servicefunksjoner. Konverter resultatet til HTTP-responser på Ktor-rutenivået, slik at forretningslogikken holdes fri for rammeverksspesifikke 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) }
    )
}

Kort sjekk

Hva gjør flatMap { } med en Either.Left-verdi?

Besvar den i den interaktive leksjonen

Oppsummering: Either<L, R>

Viktige punkter:

  • Either gjør feilbanen tydelig i funksjonssignaturen
  • Right = suksess; Left = feil (konvensjonelt)
  • map { } — transformer suksessverdien; flatMap { } — lenk sammen beregninger som kan mislykkes
  • fold(ifLeft, ifRight) — håndter begge tilfellene i ett uttrykk
  • Either.catch { } — pakk inn kode som kaster unntak, ved grensene
Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
51
Leksjoner
203
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Either<L, R>: Typet feilhåndtering uten exceptions» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Kotlin Academy, inkludert «Either<L, R>: Typet feilhåndtering uten exceptions», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Kotlin Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Either<L, R>: Typet feilhåndtering uten exceptions»?

Bruk Either til å representere suksess og feil uten å utløse unntak. Du øver på Kotlin Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Kotlin Academy?

Ingen tidligere erfaring er nødvendig. Kotlin Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Either<L, R>: Typet feilhåndtering uten exceptions»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Kotlin Academy-leksjonen?

Ja. Alle Kotlin Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Either : Typet feilhåndtering uten exceptions
  2. Arrow Raise DSL: Sammensetting av typede feil
  3. Option og nullable: Når bør De bruke hva
  4. Funksjonell domenemodellering med Arrow's kjernetyper
← Tilbake til Kotlin Academy