0Pricing
Kotlin Academy · Aula

runCatching e Result<T>

Use runCatching para encapsular exceções em Result e processá-las de modo funcional.

runCatching e Result<T> é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Result<T> em poucas palavras

Result<T> é o invólucro do Kotlin para o resultado de uma operação: um sucesso com um valor do tipo T ou uma falha com um Throwable.

Noções básicas de runCatching

runCatching { ... } executa o bloco e envolve o resultado em um Result.

fun main() {
    val good = runCatching { 10 / 2 }
    val bad  = runCatching { 10 / 0 }
    println("good isSuccess = ${good.isSuccess}")
    println("bad isFailure  = ${bad.isFailure}")
}

Extraindo o valor

getOrNull retorna o valor ou nulo. getOrThrow relança a exceção em caso de falha. getOrDefault retorna uma alternativa.

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
}

Extraindo a exceção

exceptionOrNull() retorna a exceção em caso de falha ou nulo em caso de sucesso.

fun main() {
    val r = runCatching { error("boom") }
    println(r.exceptionOrNull()?.message) // boom
}

Transformando com map

map { value -> ... } transforma o valor de sucesso. A falha passa inalterada.

fun main() {
    val r = runCatching { "10" }.map { it.toInt() * 2 }
    println(r.getOrNull()) // 20
}

mapCatching

mapCatching envolve a transformação em um try/catch para que as exceções dentro da expressão lambda também se tornem falhas.

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 } transforma falhas em sucessos ao calcular um valor de recuperação.

fun main() {
    val r = runCatching { "abc".toInt() }
        .recover { -1 }
    println(r.getOrNull()) // -1
}

onSuccess / onFailure

Use onSuccess e onFailure para executar efeitos colaterais sem alterar o Result.

fun main() {
    runCatching { "42".toInt() }
        .onSuccess { println("parsed: $it") }
        .onFailure { println("failed: ${it.message}") }
}

fold para os dois caminhos

fold(onSuccess, onFailure) retorna um tipo unificado de qualquer uma das ramificações — útil para convertê-lo em um valor pronto para a interface do usuário.

fun main() {
    val r = runCatching { "10".toInt() }
    val msg: String = r.fold(
        onSuccess = { "OK: $it" },
        onFailure = { "ERR: ${it.message}" }
    )
    println(msg)
}

Usando Result como tipo de retorno

As funções podem retornar Result<T> para tornar explícito o tratamento de erros no local da chamada.

fun parseInt(s: String): Result<Int> = runCatching { s.toInt() }
fun main() {
    parseInt("42").onSuccess { println("got $it") }
    parseInt("xx").onFailure { println("oops: ${it.message}") }
}

Encadeando operações

Combine runCatching com map, mapCatching e recover para criar fluxos contínuos de tratamento de erros.

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ção rápida

Qual construtor executa um bloco e envolve o resultado — valor ou exceção — em um Result?

Recapitulação

Result<T> representa sucesso ou falha. Crie-o com runCatching; transforme-o com map/mapCatching; recupere-se com recover; observe-o com onSuccess/onFailure; consolide-o com fold. É excelente para fluxos explícitos de tratamento de erros.

Perguntas Frequentes

A aula “runCatching e Result<T>” é grátis?

Sim — o texto completo de “runCatching e Result<T>” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “runCatching e Result<T>”?

Use runCatching para encapsular exceções em Result e processá-las de modo funcional. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “runCatching e Result<T>”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. try/catch/finally como expressão
  2. Criando classes de exceção personalizadas
  3. runCatching e Result
  4. Relançamento e encadeamento de exceções
← Voltar para Kotlin Academy