runCatching e Result<T>
Utilizzi runCatching per racchiudere le eccezioni in Result e gestirle in stile funzionale.
runCatching e Result<T> è 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.
Result<T> in breve
Result<T> è l'involucro Kotlin per l'esito di un'operazione: un successo con un valore di tipo T oppure un fallimento con un Throwable.
Nozioni di base su runCatching
runCatching { ... } esegue il blocco e ne inserisce l'esito in un Result.
fun main() {
val good = runCatching { 10 / 2 }
val bad = runCatching { 10 / 0 }
println("good isSuccess = ${good.isSuccess}")
println("bad isFailure = ${bad.isFailure}")
}Estrarre il valore
getOrNull restituisce il valore o null. getOrThrow rilancia l'eccezione in caso di fallimento. getOrDefault restituisce un valore alternativo.
fun main() {
val r = runCatching { "42".toInt() }
println(r.getOrNull()) // 42
println(r.getOrDefault(-1)) // 42
val bad = runCatching { "x".toInt() }
println(bad.getOrNull()) // null
println(bad.getOrDefault(0)) // 0
}Estrarre l'eccezione
exceptionOrNull() restituisce l'eccezione in caso di fallimento o null in caso di successo.
fun main() {
val r = runCatching { error("boom") }
println(r.exceptionOrNull()?.message) // boom
}Trasformare con map
map { value -> ... } trasforma il valore del successo. Il fallimento passa invariato.
fun main() {
val r = runCatching { "10" }.map { it.toInt() * 2 }
println(r.getOrNull()) // 20
}mapCatching
mapCatching avvolge la trasformazione in un try/catch, così anche le eccezioni all'interno della lambda diventano fallimenti.
fun main() {
val r = runCatching { "abc" }.mapCatching { it.toInt() }
println(r.isFailure) // true
println(r.exceptionOrNull()?.message) // For input string: "abc"
}recover e recoverCatching
recover { e -> fallback } trasforma i fallimenti in successi calcolando un valore di recupero.
fun main() {
val r = runCatching { "abc".toInt() }
.recover { -1 }
println(r.getOrNull()) // -1
}onSuccess / onFailure
Utilizzi onSuccess e onFailure per eseguire effetti collaterali senza modificare il Result.
fun main() {
runCatching { "42".toInt() }
.onSuccess { println("parsed: $it") }
.onFailure { println("failed: ${it.message}") }
}fold per entrambi i percorsi
fold(onSuccess, onFailure) restituisce un tipo unificato da uno dei due rami; è utile per convertirlo in un valore pronto per l'interfaccia utente.
fun main() {
val r = runCatching { "10".toInt() }
val msg: String = r.fold(
onSuccess = { "OK: $it" },
onFailure = { "ERR: ${it.message}" }
)
println(msg)
}Utilizzare Result come tipo restituito
Le funzioni possono restituire Result<T> per rendere esplicita la gestione degli errori nel punto della chiamata.
fun parseInt(s: String): Result<Int> = runCatching { s.toInt() }
fun main() {
parseInt("42").onSuccess { println("got $it") }
parseInt("xx").onFailure { println("oops: ${it.message}") }
}Concatenare le operazioni
Combini runCatching con map, mapCatching e recover per creare pipeline fluide di gestione degli errori.
fun fetchUserId(): Result<Int> = runCatching { 42 }
fun loadName(id: Int): String = "User-$id"
fun main() {
val name = fetchUserId()
.map { loadName(it) }
.recover { "Anonymous" }
.getOrNull()
println(name)
}Verifica rapida
Quale builder esegue un blocco e ne inserisce l'esito, valore o eccezione, in un Result?
Riepilogo
Result<T> rappresenta un successo o un fallimento. Lo crei con runCatching; lo trasformi con map/mapCatching; recuperi gli errori con recover; osservi l'esito con onSuccess/onFailure; unifichi i due percorsi con fold. È ideale per pipeline di gestione degli errori esplicite.
Impara Kotlin 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
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «runCatching e Result<T>» è gratuita?
Sì — il testo completo di «runCatching e Result<T>» è 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 «runCatching e Result<T>»?
Utilizzi runCatching per racchiudere le eccezioni in Result e gestirle in stile funzionale. 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 «runCatching e Result<T>»?
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
- try/catch/finally come espressione
- Creare classi di eccezioni personalizzate
- runCatching e Result
- Rilanciare eccezioni e concatenarle