Scala for Backend Engineering & Functional Programming · Lezione

Option, Try ed Either per gli errori

Implementi una gestione affidabile degli errori utilizzando `Option` per l’assenza di un valore, `Try` per le eccezioni ed `Either` per distinguere i percorsi di fallimento e successo.

Lezione 3 di 312 passaggi

Option, Try ed Either per gli errori è una lezione Scala for Backend Engineering & Functional Programming gratuita su CoddyKit. Questa è la lezione 3 di 3. 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 3 lezioni in totale.

Gestire gli errori in modo efficace

In programmazione, le cose non vanno sempre come previsto. I file potrebbero non esistere, le richieste di rete potrebbero fallire o i calcoli potrebbero produrre risultati non validi.

Come si può scrivere codice robusto in grado di gestire queste situazioni in modo efficace?
Scala offre strumenti potenti per gestire errori e valori mancanti senza ricorrere a `null` o a eccezioni ovunque.

Il problema di Null

Molti linguaggi usano null per rappresentare l'assenza di un valore. Tuttavia, null è una causa comune di bug, come la temuta NullPointerException.

Scala scoraggia l'uso di null. Offre invece tipi che indicano esplicitamente se un valore potrebbe essere assente, rendendo il codice più sicuro e facile da comprendere.

Introduzione a Scala Option

Option[A] è un contenitore che può contenere un valore di tipo A (rappresentato da Some[A]) oppure nessun valore (rappresentato da None).

Obbliga a considerare il caso in cui un valore potrebbe essere assente.
Previene NullPointerExceptions impreviste e rende il codice più esplicito.

Option in azione: Some e None

Vediamo come funziona Option. Definiremo una funzione che potrebbe restituire un nome oppure no, a seconda di un ID.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val user1 = findUser(1) // Some("Alice")
    val user2 = findUser(2) // None

    println(s"User 1: $user1")
    println(s"User 2: $user2")
  }
}

Lavorare con Option: map e getOrElse

È possibile trasformare il valore contenuto in un Option usando map oppure fornire un valore predefinito se è None usando getOrElse.

object Main {
  def findUser(id: Int): Option[String] = {
    if (id == 1) Some("Alice")
    else None
  }

  def main(args: Array[String]): Unit = {
    val userGreeting = findUser(1).map(name => s"Hello, $name!")
    val defaultGreeting = findUser(2).map(name => s"Hello, $name!").getOrElse("Hello, Guest!")

    println(s"User greeting: $userGreeting")
    println(s"Default greeting: $defaultGreeting")
  }
}

Introduzione a Scala Try

Mentre Option gestisce i valori mancanti, Try[A] è progettato per gestire calcoli che potrebbero generare un'eccezione.

Un Try può essere un Success[A] (se il calcolo termina normalmente) oppure un Failure[Throwable] (se si verifica un'eccezione).
Incapsula le eccezioni, consentendo di gestirle in modo funzionale.

Try in azione: Success e Failure

Definiamo una funzione che potrebbe generare un'eccezione (ad esempio, una divisione per zero) e racchiudiamone l'esecuzione in un Try.

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

object Main {
  def divide(a: Int, b: Int): Try[Int] = Try {
    a / b
  }

  def main(args: Array[String]): Unit = {
    val result1 = divide(10, 2) // Success(5)
    val result2 = divide(10, 0) // Failure(java.lang.ArithmeticException: / by zero)

    println(s"Result 1: $result1")
    println(s"Result 2: $result2")
  }
}

Lavorare con Try: recover e fold

Try offre metodi come recover per gestire eccezioni specifiche o fold per elaborare in modo chiaro sia i casi di successo sia quelli di errore.

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

object Main {
  def parseNumber(s: String): Try[Int] = Try(s.toInt)

  def main(args: Array[String]): Unit = {
    val num1 = parseNumber("123").getOrElse(0)
    val num2 = parseNumber("abc").getOrElse(0)

    val message = parseNumber("456").fold(
      ex => s"Failed to parse: ${ex.getMessage}",
      num => s"Parsed number: $num"
    )

    println(s"Parsed num1: $num1")
    println(s"Parsed num2: $num2")
    println(s"Message: $message")
  }
}

Introduzione a Scala Either

Either[L, R] è un tipo che rappresenta uno di due possibili valori. Per convenzione:

Left[L] rappresenta un fallimento (o il tipo di errore L).
Right[R] rappresenta un successo (o il tipo di risultato R).

A differenza di Try, Either consente di specificare un tipo significativo per l'errore, non solo un Throwable.

Either in azione: Left e Right

Ecco una funzione che convalida un indirizzo email. Restituisce un messaggio di errore String (Left) oppure l'email convalidata (Right).

object Main {
  def validateEmail(email: String): Either[String, String] = {
    if (email.contains("@") && email.contains(".")) Right(email)
    else Left("Invalid email format")
  }

  def main(args: Array[String]): Unit = {
    val email1 = validateEmail("test@example.com") // Right("test@example.com")
    val email2 = validateEmail("invalid-email")   // Left("Invalid email format")

    println(s"Email 1: $email1")
    println(s"Email 2: $email2")
  }
}

Verifica rapida: gestione degli errori

Sta scrivendo una funzione che legge un valore di configurazione da una mappa. Se la chiave esiste, vuole convertire il suo valore stringa in un intero. Se la chiave manca o la conversione non riesce, vuole restituire il valore predefinito 0.

Quale combinazione di tipi e metodi Scala sarebbe più appropriata per questa attività?

Rispondi nella lezione interattiva

Riepilogo: Option, Try, Either

Abbiamo esaminato tre potenti tipi Scala per una gestione robusta degli errori:

Option[A]: per gestire l'assenza di un valore (Some[A] o None).
Try[A]: per incapsulare calcoli che potrebbero generare eccezioni (Success[A] o Failure[Throwable]).
Either[L, R]: per rappresentare due risultati distinti, in genere un tipo di errore L e un tipo di successo R (Left[L] o Right[R]).

L'uso di questi tipi rende il codice Scala più sicuro, esplicito e funzionale!

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 «Option, Try ed Either per gli errori» è gratuita?

Sì — il testo completo di «Option, Try ed Either per gli errori» è 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 3 lezioni in totale.

Cosa imparerò in «Option, Try ed Either per gli errori»?

Implementi una gestione affidabile degli errori utilizzando `Option` per l’assenza di un valore, `Try` per le eccezioni ed `Either` per distinguere i percorsi di fallimento e successo. 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 3 di 3.

Quanto tempo richiede la lezione «Option, Try ed Either per gli errori»?

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

Approfondimento sulle collezioni immutabili
Operazioni funzionali sulle collezioni
Option, Try ed Either per gli errori

← Torna a Scala for Backend Engineering & Functional Programming