Kotlin Academy · Aula

Quando Usar Cada Uma

Vantagens e desvantagens

Quando Usar Cada Uma é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 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.

Duas ferramentas, funções diferentes

As funções infixas tratam de legibilidade; as funções recursivas de cauda tratam de recursão segura e eficiente. Elas resolvem problemas independentes.

infix fun Int.add(o: Int) = this + o

tailrec fun sum(n: Int, acc: Int = 0): Int =
    if (n == 0) acc else sum(n - 1, acc + n)

fun main() {
    println(2 add 3)
    println(sum(10))
}

Escolha funções infixas para APIs fluentes

Prefira funções infixas quando uma chamada ficar melhor sem pontos e parênteses, especialmente em DSLs e na criação de pares.

fun main() {
    val pair = "id" to 100
    println(pair)
}

Escolha tailrec para recursão profunda

Use tailrec quando um algoritmo recursivo puder atingir uma profundidade suficiente para estourar a pilha.

tailrec fun count(n: Int, acc: Int = 0): Int =
    if (n == 0) acc else count(n - 1, acc + 1)

fun main() {
    println(count(50000))
}

Compensações das funções infixas

As funções infixas removem a pontuação, o que pode reduzir a clareza para leitores que não as conhecem e complicar a precedência. Use-as somente quando ajudarem claramente.

infix fun Int.scaledBy(f: Int) = this * f

fun main() {
    println(5 scaledBy 3)
}

Compensações da recursão de cauda

Transformar o código em recursivo de cauda geralmente exige um acumulador, o que pode parecer menos direto do que um laço comum. Pondere a expressividade em relação à simplicidade.

tailrec fun product(n: Int, acc: Long = 1): Long =
    if (n <= 1) acc else product(n - 1, acc * n)

fun main() {
    println(product(6))
}

Quando um laço é mais simples

Se um laço comum for ou while for mais claro do que a recursão de cauda, prefira o laço. A recursão é uma ferramenta, não uma exigência.

fun sumLoop(n: Int): Int {
    var total = 0
    for (i in 1..n) total += i
    return total
}

fun main() {
    println(sumLoop(10))
}

Quando uma chamada nomeada é mais clara

Se um nome de função infixa não representar obviamente uma relação binária, uma chamada de método normal comunicará melhor a intenção.

data class Temp(val c: Int) {
    fun isWarmerThan(o: Temp) = c > o.c
}

fun main() {
    println(Temp(30).isWarmerThan(Temp(20)))
}

Combinando ambos

Os dois recursos são independentes; um único programa pode usar funções infixas para chamadas legíveis e recursão de cauda para uma recursão segura.

infix fun Int.upto(n: Int) = (this..n).toList()

tailrec fun last(list: List<Int>): Int =
    if (list.size == 1) list[0] else last(list.drop(1))

fun main() {
    println(last(1 upto 5))
}

Lista de verificação da legibilidade

Pergunte: as funções infixas tornam a chamada mais clara para quem está começando? A recursão de cauda evita um risco real de estouro? Se não, prefira funções comuns e laços.

fun main() {
    val r = (1..5).sum()
    println(r)
}

Observação sobre desempenho

A recursão de cauda oferece desempenho semelhante ao de um laço, usando espaço constante na pilha. As funções infixas não têm custo em tempo de execução; são puramente sintáticas.

tailrec fun pow(base: Int, exp: Int, acc: Long = 1): Long =
    if (exp == 0) acc else pow(base, exp - 1, acc * base)

fun main() {
    println(pow(2, 10))
}

Resumo da decisão

Funções infixas: chamadas fluentes, binárias e com um argumento. Recursão de cauda: recursão que precisa ser escalada com segurança. Nenhum dos dois é padrão; ambos são escolhas deliberadas.

infix fun String.joinWith(o: String) = "$this-$o"

fun main() {
    println("a" joinWith "b")
}

Verificação rápida

Teste sua compreensão sobre quando usar cada recurso.

Recapitulação

Você aprendeu quando usar cada recurso:

Use infix para chamadas binárias fluentes e legíveis e para DSLs.
Use tailrec para recursão que precisa crescer sem estourar a pilha.
Prefira laços comuns ou funções nomeadas quando forem mais claros.
Os dois recursos são independentes e podem ser combinados.

infix fun Int.by(o: Int) = this * o
tailrec fun dec(n: Int): Int = if (n == 0) 0 else dec(n - 1)

fun main() {
    println(3 by 4)
    println(dec(1000))
}

Perguntas Frequentes

A aula “Quando Usar Cada Uma” é grátis?

Sim — o texto completo de “Quando Usar Cada Uma” é 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 “Quando Usar Cada Uma”?

Vantagens e desvantagens 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 4 de 4.

Quanto tempo leva a aula “Quando Usar Cada Uma”?

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

← Voltar para Kotlin Academy