Scala for Backend Engineering & Functional Programming · Lezione

Try, Success, Failure

Gestione delle eccezioni

Lezione 2 di 413 passaggi

Try, Success, Failure è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Scala for Backend Engineering & Functional Programming, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Che cos'è Try?

Try[T] rappresenta un calcolo che può produrre un valore oppure generare un'eccezione. Ha due sottotipi:

Success[T] racchiude un risultato normale.
Failure racchiude un Throwable.

Trasforma il codice che genera eccezioni in un valore componibile.

Importare Try

Try si trova in scala.util. Racchiuda in Try { ... } qualsiasi espressione che potrebbe generare un'eccezione: le eccezioni non fatali verranno intercettate automaticamente.

import scala.util.Try

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

Success e Failure

Un Try che termina normalmente è un Success contenente il valore; uno che genera un'eccezione diventa un Failure contenente l'eccezione.

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

Pattern matching sugli errori

Quando il codice racchiuso genera un'eccezione, può esaminare l'eccezione all'interno di Failure. In questo caso un'analisi non valida viene catturata in modo ordinato.

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 con Try

getOrElse restituisce il valore del risultato positivo oppure un valore predefinito quando Try ha avuto esito negativo. In questo modo evita completamente di generare un'eccezione.

import scala.util.Try

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

map su Try

map trasforma un valore Success. Se l'originale è un Failure oppure la funzione di trasformazione genera un'eccezione, il risultato rimane un 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: gestire l'eccezione

recover consente di trasformare nuovamente un Failure in un Success, gestendo eccezioni specifiche con una funzione parziale.

import scala.util.Try

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

recoverWith

recoverWith è simile a recover, ma il gestore restituisce un altro Try invece di un valore semplice. Lo usi quando anche il recupero potrebbe fallire.

import scala.util.Try

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

toEither e toOption

Try può essere convertito facilmente in altri tipi per la gestione degli errori:

toOption: Success diventa Some, Failure diventa None.
toEither: Success diventa Right, Failure diventa 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)
}

Concatenare con flatMap

flatMap mette in sequenza calcoli che restituiscono ciascuno un Try. Se un passaggio fallisce, l'intera catena si interrompe e restituisce direttamente quel Failure.

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 a confronto con try/catch

Try trasforma le eccezioni in valori, consentendo di usare map, flatMap e combinare i risultati senza blocchi try/catch annidati. Intercetta solo le eccezioni non fatali; gli errori gravi, come OutOfMemoryError, continuano a propagarsi.

Verifica rapida

Verifichi la sua conoscenza di Try.

Rispondi nella lezione interattiva

Riepilogo

Ha imparato a gestire le eccezioni con Try:

Try { ... } cattura le eccezioni non fatali come Failure e i risultati normali come Success.
Trasformi i risultati con map/flatMap e gestisca il recupero con recover/recoverWith.
Fornisca valori predefiniti con getOrElse.
Converta con toOption e toEither.

Gratis per iniziare

Impara Scala con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 39
Lezioni: 143

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Try, Success, Failure» è gratuita?

Sì — il testo completo di «Try, Success, Failure» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Scala for Backend Engineering & Functional Programming, passa a CoddyKit PRO. Il corso Scala for Backend Engineering & Functional Programming include 4 lezioni in totale.

Cosa imparerò in «Try, Success, Failure»?

Gestione delle eccezioni Eserciti Scala for Backend Engineering & Functional Programming con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Scala for Backend Engineering & Functional Programming?

Non è richiesta alcuna esperienza precedente. Scala for Backend Engineering & Functional Programming su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Try, Success, Failure»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Scala for Backend Engineering & Functional Programming?

Sì. Ogni lezione Scala for Backend Engineering & Functional Programming include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Scala for Backend Engineering & Functional Programming