also: efeitos colaterais sem alterar o receptor
Use also para registro, depuração e operações que produzem apenas efeitos colaterais.
also: efeitos colaterais sem alterar o receptor é 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.
also em resumo
also executa um bloco com o receptor como it e retorna o receptor sem alterações. É perfeito para efeitos colaterais — registro, depuração e validação — sem interromper um fluxo.
Noções básicas de also
also { ... } executa um efeito colateral e devolve o mesmo valor, para que as chamadas fluam naturalmente.
fun main() {
val nums = listOf(1, 2, 3, 4)
.also { println("input: $it") }
.filter { it % 2 == 0 }
.also { println("filtered: $it") }
println(nums)
}also para registro
Adicione instruções de registro no meio do fluxo sem interrompê-lo.
fun main() {
val processed = " Hello, Kotlin! "
.also { println("raw: '$it'") }
.trim()
.also { println("trimmed: '$it'") }
.uppercase()
println(processed)
}also para depuração
Use also para inspecionar o estado intermediário durante uma refatoração — você poderá removê-lo depois sem alterar o fluxo.
fun main() {
val sum = (1..5).toList()
.also { println("list: $it") }
.sum()
.also { println("sum: $it") }
println("final: $sum")
}also versus apply
apply usa this (melhor para atribuições). also usa it (melhor para referências explícitas e efeitos colaterais).
class Counter {
var value: Int = 0
}
fun main() {
val c = Counter().apply { value = 10 } // uses this implicitly
val d = Counter().also { it.value = 10 } // uses it explicitly
println("${c.value} / ${d.value}")
}also para efeitos colaterais na inicialização
É útil quando você precisa fazer algo com um objeto durante a criação que não seja definir uma propriedade.
class Repository {
val cache = mutableMapOf<String, String>()
fun init() = println("Repository initialized")
}
fun main() {
val r = Repository().also { it.init() }
r.cache["key"] = "value"
println(r.cache)
}also retorna o original
O receptor passa sem alterações — fácil de encadear.
fun main() {
val len = "Hello".also { println("got: $it") }.length
println(len) // 5
}also para validação
Execute asserções no meio do fluxo.
fun main() {
val n = listOf(1, 2, 3, 4)
.filter { it > 0 }
.also { require(it.isNotEmpty()) { "must have positives" } }
.sum()
println(n)
}Combinando also e let
Use also para efeitos colaterais e let para transformação no mesmo fluxo.
fun main() {
val raw: String? = " 42 "
val n = raw
?.also { println("raw: '$it'") }
?.let { it.trim().toIntOrNull() }
?.also { println("parsed: $it") }
println(n)
}also para adicionar a uma coleção
Adicione um objeto construído a uma lista diretamente no fluxo.
class User(val name: String)
fun main() {
val users = mutableListOf<User>()
val ada = User("Ada").also { users.add(it) }
val ben = User("Ben").also { users.add(it) }
println(users.map { it.name })
}Quando usar also
Escolha also quando precisar de um efeito colateral (registrar, validar ou cadastrar), mas quiser que o valor original continue no fluxo.
fun main() {
val total = listOf(10, 20, 30, 40, 50)
.also { println("count: ${it.size}") }
.filter { it >= 30 }
.also { println("kept: $it") }
.sum()
println("total: $total")
}Antipadrão: usar also para reatribuição
Não use also quando você realmente precisa transformar um valor — para isso, use let/run.
fun main() {
val name = "ada"
// BAD: also returns receiver, so upper is wrong
// val upper = name.also { it.uppercase() } // upper == "ada"
val upper = name.let { it.uppercase() }
println(upper) // ADA
}Verificação rápida
Que valor also retorna depois de executar seu bloco?
Recapitulação
also executa um bloco de efeito colateral com it e retorna o receptor. Use-o para registro, depuração, validação e cadastro — sempre que precisar observar um valor sem alterá-lo. Para transformações, use let ou run.
Perguntas Frequentes
A aula “also: efeitos colaterais sem alterar o receptor” é grátis?
Sim — o texto completo de “also: efeitos colaterais sem alterar o receptor” é 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 “also: efeitos colaterais sem alterar o receptor”?
Use also para registro, depuração e operações que produzem apenas efeitos colaterais. 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 “also: efeitos colaterais sem alterar o receptor”?
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
- apply e with: configurando e retornando
- let e run: transformando e delimitando o escopo
- also: efeitos colaterais sem alterar o receptor
- Escolhendo a função de escopo certa: guia de decisão