Kotlin Academy · Lezione

Gerarchie Result sealed

Tipi Result personalizzati

Gerarchie Result sealed è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 3 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 Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Oltre il Result integrato

Il Result di Kotlin contiene solo un'eccezione in caso di fallimento. Spesso si desiderano informazioni sugli errori più ricche e tipizzate. Una gerarchia di classi sealed consente di modellare esattamente gli esiti previsti dal dominio.

Un esito sealed

Definisca un tipo sealed con sottoclassi per il successo e per l'errore. Il compilatore conosce tutti i casi e consente una gestione esaustiva.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun main() {
    val r: Outcome<Int> = Outcome.Ok(5)
    println(r)
}

when esaustivo

Poiché il tipo è sealed, un when su di esso non richiede else e il compilatore impone di gestire ogni caso.

sealed class Outcome<out T> {
    data class Ok<T>(val value: T) : Outcome<T>()
    data class Err(val message: String) : Outcome<Nothing>()
}

fun describe(o: Outcome<Int>) = when (o) {
    is Outcome.Ok -> "value " + o.value
    is Outcome.Err -> "error " + o.message
}

fun main() {
    println(describe(Outcome.Ok(9)))
    println(describe(Outcome.Err("boom")))
}

Varianti di errore tipizzate

Modelli i diversi tipi di fallimento come sottoclassi separate, ognuna contenente i dati pertinenti. È una soluzione migliore di una singola eccezione opaca.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun main() {
    val r: Fetch<String> = Fetch.NotFound(42)
    println(r)
}

Gestire ogni variante

Un when può reagire in modo specifico a ogni tipo di errore, con tutti i dati disponibili per ciascun ramo.

sealed class Fetch<out T> {
    data class Success<T>(val data: T) : Fetch<T>()
    data class NotFound(val id: Int) : Fetch<Nothing>()
    data class Network(val code: Int) : Fetch<Nothing>()
}

fun handle(f: Fetch<String>) = when (f) {
    is Fetch.Success -> "data: " + f.data
    is Fetch.NotFound -> "missing id " + f.id
    is Fetch.Network -> "net error " + f.code
}

fun main() {
    println(handle(Fetch.Network(503)))
}

Il trucco di Nothing

Le varianti di errore che non contengono alcun valore di successo usano Outcome<Nothing>. Poiché Nothing è un sottotipo di ogni tipo e il generico è out, un errore è compatibile con qualsiasi Outcome<T>.

sealed class Res<out T> {
    data class Ok<T>(val v: T) : Res<T>()
    object Empty : Res<Nothing>()
}

fun get(flag: Boolean): Res<String> =
    if (flag) Res.Ok("hi") else Res.Empty

fun main() {
    println(get(false))
}

object per i casi senza stato

Se una variante di errore non contiene dati, la dichiari come singleton object invece che come classe.

sealed class Login {
    data class Success(val user: String) : Login()
    object WrongPassword : Login()
    object Locked : Login()
}

fun main() {
    val r: Login = Login.WrongPassword
    println(r === Login.WrongPassword)
}

Restituire la gerarchia

Le funzioni restituiscono il tipo sealed; i chiamanti devono gestire ogni esito, eliminando i percorsi di errore dimenticati.

sealed class Parsed {
    data class Num(val value: Int) : Parsed()
    data class Bad(val input: String) : Parsed()
}

fun parse(s: String): Parsed {
    val n = s.toIntOrNull()
    return if (n != null) Parsed.Num(n) else Parsed.Bad(s)
}

fun main() {
    when (val r = parse("x")) {
        is Parsed.Num -> println(r.value)
        is Parsed.Bad -> println("bad: " + r.input)
    }
}

Sealed e Result integrato a confronto

Usi il Result integrato per una cattura rapida basata sulle eccezioni. Usi una gerarchia sealed personalizzata quando servono più casi di errore tipizzati, con dati specifici del dominio e gestione esaustiva.

Progettare la gerarchia

Una buona progettazione di un risultato sealed prevede:

Una variante di successo che contiene il payload
Una sottoclasse per ogni modalità di fallimento significativa
Varianza out T con Nothing per i casi che contengono solo un errore

Il compilatore come rete di sicurezza

Il vantaggio principale è questo: quando in seguito aggiunge una nuova variante, ogni when non esaustivo diventa un errore di compilazione, indicandole ogni punto che deve gestirla. Gli errori non possono passare inosservati.

Verifica rapida

Verifichi la Sua comprensione delle gerarchie sealed per i risultati.

Riepilogo

Ha creato gerarchie sealed per i risultati:

Successo più varianti di errore tipizzate
when esaustivo senza else
out T e Nothing per i casi che contengono solo un errore
Gestione delle nuove varianti imposta dal compilatore

Prossimo argomento: gestione funzionale degli errori con map e recover.

Domande Frequenti

La lezione «Gerarchie Result sealed» è gratuita?

Sì — il testo completo di «Gerarchie Result sealed» è 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 Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Gerarchie Result sealed»?

Tipi Result personalizzati Eserciti Kotlin Academy 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 Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy 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 4.

Quanto tempo richiede la lezione «Gerarchie Result sealed»?

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 Kotlin Academy?

Sì. Ogni lezione Kotlin Academy 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 Kotlin Academy