let, also e run com receptores anuláveis
Use funções de escopo para executar código somente quando um valor não for nulo.
let, also e run com receptores anuláveis é 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.
Funções de escopo encontram valores anuláveis
As funções de escopo let, also e run combinam muito bem com a chamada segura ?. para executar um bloco somente quando o receptor não é null.
Uso de uma função de escopo com chamada segura
obj?.let { ... } executa o bloco somente se obj não for null; dentro dele, it se refere ao valor não anulável.
fun main() {
val name: String? = "Kotlin"
name?.let {
println("Length: ${it.length}")
println("Upper: ${it.uppercase()}")
}
}O bloco é ignorado quando o valor é nulo
Se o receptor for null, todo o bloco let será ignorado.
fun main() {
val name: String? = null
val result = name?.let {
println("never printed")
it.length
}
println(result) // null
}Uma função de escopo retorna um valor
let retorna a última expressão do bloco — por isso pode ser encadeado com o Elvis para fornecer valores padrão.
fun main() {
val raw: String? = " hello "
val cleaned = raw?.let { it.trim().uppercase() } ?: "(empty)"
println(cleaned) // HELLO
}also para efeitos colaterais
also executa um bloco para realizar efeitos colaterais e retorna o receptor original — excelente para registrar informações em um fluxo encadeado.
fun main() {
val name: String? = "Alice"
val len = name?.also { println("Processing: $it") }?.length
println("len = $len")
}also preserva o valor
Diferentemente de let, also retorna o receptor sem alterações. Use-o quando quiser observar o valor sem transformá-lo.
fun main() {
val items: List<Int>? = listOf(1, 2, 3)
items?.also { println("Got list of size ${it.size}") }
?.forEach { println(it) }
}run com chamada segura
obj?.run { ... } executa o bloco com this vinculado ao receptor. Use-o quando quiser acessar membros sem o prefixo it..
fun main() {
val name: String? = "Kotlin"
val info = name?.run {
"len=$length upper=${uppercase()}"
}
println(info)
}Argumento lambda versus receptor
let usa it (argumento da lambda); run usa this (receptor). Escolha a opção que resultar em uma leitura melhor.
class User(val name: String, val age: Int)
fun main() {
val user: User? = User("Ada", 35)
user?.let { "${it.name} age ${it.age}" }.also(::println)
user?.run { "$name age $age" }.also(::println)
}Encadeando vários escopos
Encadeie funções de escopo em um fluxo de dados para transformar os dados passo a passo e registrar informações.
fun main() {
val raw: String? = " hello "
val result = raw
?.also { println("raw: '$it'") }
?.let { it.trim() }
?.also { println("trimmed: '$it'") }
?.uppercase()
println(result) // HELLO
}Filtragem condicional com takeIf
Combine takeIf (filtragem) com let para executar uma operação com base em um predicado.
fun main() {
val name: String? = "Kotlin"
name?.takeIf { it.length > 3 }
?.let { println("Long name: $it") }
}Antipadrão: ifs aninhados
Antes das funções de escopo:
fun main() {
val name: String? = "Alice"
// OLD WAY:
if (name != null) {
val upper = name.uppercase()
println(upper)
}
// NEW WAY:
name?.let { println(it.uppercase()) }
}Verificação rápida
Qual função de escopo retorna o receptor sem alterações e é usada principalmente para efeitos colaterais?
Recapitulação
Combine ?. com let (o bloco retorna um valor e usa it), run (o bloco retorna um valor e usa this) ou also (retorna o receptor e serve para efeitos colaterais). Todas ignoram a execução se o receptor for null.
Aprenda Kotlin com um tutor de IA — grátis
Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.
- Cursos
- 51
- Aulas
- 203
Perguntas Frequentes
A aula “let, also e run com receptores anuláveis” é grátis?
Sim — o texto completo de “let, also e run com receptores anuláveis” é 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 “let, also e run com receptores anuláveis”?
Use funções de escopo para executar código somente quando um valor não for nulo. 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 “let, also e run com receptores anuláveis”?
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
- Tipos anuláveis e o modificador ?
- Chamada segura ?. e Elvis ?: em código real
- let, also e run com receptores anuláveis
- Operador !!: quando e por que evitá-lo