Escolhendo a função de escopo certa: guia de decisão
Selecione a função de escopo correta com base no receptor, no tipo de retorno e na intenção.
Escolhendo a função de escopo certa: guia de decisão é 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.
Cinco funções, dois eixos
As funções de escopo do Kotlin variam em dois eixos: estilo do receptor (this ou it) e valor retornado (receptor ou resultado da lambda). Escolha com base na intenção.
A matriz de decisão
apply: this / receptor. also: it / receptor. run: this / lambda. let: it / lambda. with: this / lambda (sem receptor por meio de ponto).
apply: configurar e retornar
Use apply para configurar objetos em um fluxo no estilo construtor.
class Config {
var host: String = ""
var port: Int = 0
}
fun main() {
val cfg = Config().apply {
host = "localhost"
port = 8080
}
println("${cfg.host}:${cfg.port}")
}also: efeitos colaterais
Use also para registrar, validar ou disparar um efeito colateral enquanto o receptor continua no fluxo.
fun main() {
val items = listOf(1, 2, 3, 4)
.also { println("got ${it.size} items") }
.filter { it % 2 == 0 }
println(items)
}let: transformar e garantir segurança contra nulos no escopo
Use let para transformações seguras contra nulos ou para limitar o escopo de uma variável.
fun main() {
val name: String? = "Ada"
val length = name?.let { it.length } ?: 0
println(length)
}run: acesso a vários membros com resultado
Use run ao calcular um resultado a partir de vários membros do receptor — você economiza os prefixos it..
class User(val name: String, val age: Int)
fun main() {
val description = User("Ada", 35).run {
"Name: $name, Age: $age"
}
println(description)
}with: agrupar operações em um objeto existente
Use with(obj) { ... } quando não controlar o local da chamada (sem fluxo com ponto), mas quiser agrupar operações usando this.
class Builder {
val parts = mutableListOf<String>()
fun add(s: String) { parts.add(s) }
fun build(): String = parts.joinToString("-")
}
fun main() {
val b = Builder()
val result = with(b) {
add("hello")
add("kotlin")
build()
}
println(result) // hello-kotlin
}Escolhendo com base na intenção
Pergunte: (1) Preciso receber o receptor de volta ou de um resultado derivado? (2) Prefiro this ou it? As respostas determinam a função.
class Box { var w = 0; var h = 0; fun area() = w * h }
fun main() {
// Configure and return Box -> apply
val box = Box().apply { w = 3; h = 4 }
// Compute area from box -> let or run
val area = box.let { it.area() }
// Side effect, keep box -> also
val sameBox = box.also { println("area=${it.area()}") }
println("$box / $area / $sameBox")
}Comparação: apply versus also
Ambas retornam o receptor. apply usa this (bom para definir campos). also usa it (bom para referenciar o receptor explicitamente, geralmente em efeitos colaterais).
class Item { var name = "" }
fun main() {
val a = Item().apply { name = "apply" } // implicit this
val b = Item().also { it.name = "also" } // explicit it
println("${a.name} / ${b.name}")
}Comparação: let versus run
Ambas retornam o resultado da lambda. let usa it (bom para transformações simples e segurança contra nulos). run usa this (bom quando você chama muitos membros).
class Calculator(val a: Int, val b: Int) {
fun sum() = a + b
fun product() = a * b
}
fun main() {
val calc = Calculator(3, 4)
val s = calc.let { it.sum() } // simple
val combo = calc.run { "sum=${sum()} product=${product()}" } // multi-member
println("$s / $combo")
}Fluxo prático
Um fluxo real geralmente usa várias funções de escopo em conjunto.
class Request(var url: String = "", var headers: Map<String, String> = emptyMap())
fun main() {
val response = Request()
.apply {
url = "https://api.example.com"
headers = mapOf("Accept" to "json")
}
.also { println("request: ${it.url}") }
.let { req -> "GET ${req.url}" }
println(response)
}Guia rápido
Uma referência rápida para escolher a ferramenta certa.
// apply: this, returns receiver — configure object
// also: it, returns receiver — side effects in chain
// let: it, returns lambda result — transform / null-safety
// run: this, returns lambda result — multi-member compute
// with: this, returns lambda result — group operations on existing obj
fun main() { println("Scope functions: pick by receiver style + return value") }Verificação rápida
Qual função de escopo usa this como receptor AND retorna o próprio receptor?
Recapitulação
Escolha a função de escopo pela intenção: apply (configuração + retornar o próprio receptor), also (efeito colateral + retornar o próprio receptor), let (transformar com it), run (transformar com this), with (agrupar operações em um objeto existente). Dois eixos — estilo do receptor e valor retornado — determinam a escolha certa.
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 “Escolhendo a função de escopo certa: guia de decisão” é grátis?
Sim — o texto completo de “Escolhendo a função de escopo certa: guia de decisão” é 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 “Escolhendo a função de escopo certa: guia de decisão”?
Selecione a função de escopo correta com base no receptor, no tipo de retorno e na intenção. 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 “Escolhendo a função de escopo certa: guia de decisão”?
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