Scala för backendutveckling och funktionell programmering · Lektion

Try, Success, Failure

Undantagshantering.

Lektion 2 av 413 steg

Try, Success, Failure är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 2 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.

Vad är Try?

Try[T] representerar en beräkning som antingen kan resultera i ett värde eller kasta ett undantag. Den har två undertyper:

Success[T] kapslar in ett normalt resultat.
Failure kapslar in ett Throwable.

Den omvandlar kod som kastar undantag till ett värde som ni kan komponera.

Importera Try

Try finns i scala.util. Placera uttryck som kan kasta undantag inuti Try { ... }, så fångar det icke-fatala undantag åt er.

import scala.util.Try

@main def run(): Unit = {
  val ok = Try(10 / 2)
  val bad = Try(10 / 0)
  println(ok)
  println(bad)
}

Success och Failure

En Try som slutförs normalt är en Success som innehåller värdet; en som kastar ett undantag blir en Failure som innehåller undantaget.

import scala.util.{Try, Success, Failure}

@main def run(): Unit = {
  val result = Try("123".toInt)
  result match {
    case Success(n) => println(s"parsed: $n")
    case Failure(e) => println(s"failed: ${e.getMessage}")
  }
}

Mönstermatcha fel

När den inneslutna koden kastar ett undantag kan ni granska undantaget inuti Failure. Här fångas en felaktig parsning på ett tydligt sätt.

import scala.util.{Try, Success, Failure}

@main def run(): Unit = {
  val result = Try("abc".toInt)
  result match {
    case Success(n) => println(s"got $n")
    case Failure(e) => println(s"error type: ${e.getClass.getSimpleName}")
  }
}

getOrElse med Try

getOrElse returnerar det lyckade värdet eller ett standardvärde när Try misslyckades. På så sätt undviker ni att kasta ett undantag över huvud taget.

import scala.util.Try

@main def run(): Unit = {
  val n = Try("oops".toInt).getOrElse(-1)
  println(n)
}

map på Try

map transformerar ett Success-värde. Om det ursprungliga värdet är en Failure, eller om transformeringsfunktionen kastar ett undantag, förblir resultatet en Failure.

import scala.util.Try

@main def run(): Unit = {
  val doubled = Try("21".toInt).map(_ * 2)
  val failed  = Try("x".toInt).map(_ * 2)
  println(doubled)
  println(failed)
}

recover: Hantera undantaget

recover låter er omvandla en Failure tillbaka till en Success genom att hantera specifika undantag med en partiell funktion.

import scala.util.Try

@main def run(): Unit = {
  val safe = Try("x".toInt).recover {
    case _: NumberFormatException => 0
  }
  println(safe)
}

recoverWith

recoverWith fungerar som recover, men hanteraren returnerar en annan Try i stället för ett vanligt värde. Använd den när återställningen själv kan misslyckas.

import scala.util.Try

@main def run(): Unit = {
  val result = Try("x".toInt).recoverWith {
    case _: NumberFormatException => Try("42".toInt)
  }
  println(result)
}

toEither och toOption

Try kan enkelt konverteras till andra feltyper:

toOption: Success blir Some, Failure blir None.
toEither: Success blir Right, Failure blir Left(throwable).

import scala.util.Try

@main def run(): Unit = {
  println(Try("5".toInt).toOption)
  println(Try("x".toInt).toOption)
  println(Try("5".toInt).toEither.isRight)
}

Kedja med flatMap

flatMap sekvenserar beräkningar som var och en returnerar en Try. Om något steg misslyckas avbryts hela kedjan och blir den Failure som uppstod.

import scala.util.Try

object Main {
  def half(n: Int): Try[Int] = Try(if (n % 2 == 0) n / 2 else throw new RuntimeException("odd"))

  def main(args: Array[String]): Unit = {
    println(Try("8".toInt).flatMap(half))
    println(Try("7".toInt).flatMap(half))
  }
}

Try jämfört med try/catch

Try omvandlar undantag till värden, så att ni kan använda map, flatMap och kombinera resultat utan nästlade try/catch-block. Den fångar bara icke-fatala undantag; allvarliga fel som OutOfMemoryError fortsätter att spridas.

Snabbtest

Testa era kunskaper om Try.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att hantera undantag med Try:

Try { ... } fångar icke-fatala undantag som Failure och normala resultat som Success.
Transformera med map/flatMap; återställ med recover/recoverWith.
Ange standardvärden med getOrElse.
Konvertera med toOption och toEither.

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Try, Success, Failure” gratis?

Ja – hela texten till ”Try, Success, Failure” 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 ”Try, Success, Failure”?

Undantagshantering. 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 2 av 4.

Hur lång tid tar lektionen ”Try, Success, Failure”?

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.

Alla lektioner i den här kursen

← Tillbaka till Scala för backendutveckling och funktionell programmering