Either för fel
Left och Right.
Either för fel är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 1 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 Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.
Varför Either?
Either representerar ett värde som kan vara ett av två möjliga alternativ. Det är det idiomatiska sättet att modellera beräkningar som kan misslyckas med information om felet.
Leftinnehåller konventionellt felet.Rightinnehåller konventionellt det lyckade resultatet.
Till skillnad från Option, som bara talar om att något saknas, talar Either om vad som gick fel.
Either-typen
Either[A, B] är ett förseglat trait med två undertyper: Left[A] och Right[B].
Kom ihåg: Right is right (rätt), medan Left är felet. Den här konventionen gör att map och flatMap automatiskt arbetar på den lyckade sidan.
val ok: Either[String, Int] = Right(42)
val err: Either[String, Int] = Left("boom")
println(ok)
println(err)Returnera Either från en funktion
En funktion som kan misslyckas returnerar en Either i stället för att kasta ett undantag. Anroparen kan då hantera båda resultaten explicit.
object Main {
def parseAge(s: String): Either[String, Int] =
s.toIntOption match {
case Some(n) if n >= 0 => Right(n)
case Some(_) => Left("age cannot be negative")
case None => Left("not a number")
}
def main(args: Array[String]): Unit = {
println(parseAge("30"))
println(parseAge("-5"))
println(parseAge("x"))
}
}Mönstermatchning på Either
Det mest direkta sättet att använda en Either är mönstermatchning. Hantera Left och Right separat.
@main def run(): Unit = {
val result: Either[String, Int] = Right(10)
val msg = result match {
case Right(value) => s"Got value: $value"
case Left(error) => s"Failed: $error"
}
println(msg)
}fold: Slå ihop båda sidor
fold tar två funktioner: en för Left och en för Right, och producerar ett enda resultat av en gemensam typ.
Det är ett kortfattat alternativ till mönstermatchning när ni vill få tillbaka ett värde.
@main def run(): Unit = {
val r: Either[String, Int] = Right(7)
val label = r.fold(
err => s"error: $err",
num => s"double is ${num * 2}"
)
println(label)
}map arbetar med Right
map transformerar värdet i Right och lämnar en Left orörd. Detta är det högerorienterade beteendet hos Scalās Either (sedan 2.12).
@main def run(): Unit = {
val ok: Either[String, Int] = Right(5)
val no: Either[String, Int] = Left("missing")
println(ok.map(_ + 1))
println(no.map(_ + 1))
}getOrElse och standardvärden
getOrElse hämtar värdet i Right eller returnerar ett reservvärde när Either är en Left.
@main def run(): Unit = {
val ok: Either[String, Int] = Right(99)
val no: Either[String, Int] = Left("oops")
println(ok.getOrElse(0))
println(no.getOrElse(0))
}swap: Byt plats på sidorna
swap byter plats på Left och Right. Det är praktiskt när ni vill arbeta med felsidan med hjälp av högerorienterade metoder.
@main def run(): Unit = {
val err: Either[String, Int] = Left("bad input")
val swapped = err.swap.map(_.toUpperCase)
println(swapped)
}isLeft och isRight
Snabba booleska kontroller låter er förgrena koden utan fullständig mönstermatchning.
isRightreturnerar true för ett lyckat resultat.isLeftreturnerar true för ett fel.
@main def run(): Unit = {
val r: Either[String, Int] = Right(1)
println(r.isRight)
println(r.isLeft)
}toOption: Kasta bort felet
När ni inte längre bryr er om varför något misslyckades konverterar toOption en Either till en Option: Right(x) blir Some(x) och Left(_) blir None.
@main def run(): Unit = {
val ok: Either[String, Int] = Right(3)
val no: Either[String, Int] = Left("err")
println(ok.toOption)
println(no.toOption)
}Ett valideringsexempel
Så här sätter ni ihop delarna: validera ett användarnamn och returnera ett typat fel vid misslyckande.
object Main {
def validate(name: String): Either[String, String] =
if (name.isEmpty) Left("empty name")
else if (name.length > 10) Left("name too long")
else Right(name)
def main(args: Array[String]): Unit = {
println(validate("alice"))
println(validate(""))
println(validate("verylongusername"))
}
}Snabbtest
Testa er förståelse av Either-konventionerna.
Sammanfattning
Ni har lärt er att modellera fel med Either:
Right= lyckat resultat,Left= fel (högerorienterat).- Använd mönstermatchning eller
fold. - Transformera det lyckade resultatet med
map; ange standardvärden medgetOrElse. - Byt plats på sidorna med
swap; konvertera medtoOption.
Härnäst hanterar ni undantag med Try.
Lär dig Scala 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
- 39
- Lektioner
- 143
Vanliga frågor
Är lektionen ”Either för fel” gratis?
Ja – hela texten till ”Either för fel” 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 Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.
Vad lär jag mig i ”Either för fel”?
Left och Right. Ni övar på Scala för backendutveckling och funktionell programmering 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 Scala för backendutveckling och funktionell programmering?
Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering 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 4.
Hur lång tid tar lektionen ”Either för fel”?
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 Scala för backendutveckling och funktionell programmering-lektionen?
Ja. Varje Scala för backendutveckling och funktionell programmering-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.