0Pricing
Kotlin Academy · Aula

let e run: transformando e delimitando o escopo

Aplique let a transformações seguras contra nulos e run a computações locais.

let e run: transformando e delimitando o escopo é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 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.

let e run

let usa it como receptor; run usa this. Ambas retornam a última expressão da lambda. Escolha com base na sua preferência por referências explícitas.

Noções básicas de let

let passa o receptor para a lambda como it. É útil para transformar um valor ou limitar o escopo de uma variável.

fun main() {
    val length = "Kotlin".let { it.length }
    println(length) // 6
}

let com valor anulável

Uma expressão idiomática clássica: obj?.let { ... } executa o bloco somente quando obj não é nulo.

fun main() {
    val name: String? = "Ada"
    val upper = name?.let { it.uppercase() } ?: "(unknown)"
    println(upper) // ADA
}

Usando let para transformar

Use let para converter um valor mantendo o fluxo legível.

fun main() {
    val numStr = "42"
    val doubled = numStr.let { it.toInt() }.let { it * 2 }
    println(doubled) // 84
}

Usando let para limitar o escopo

Restrinja a visibilidade de uma variável a um bloco pequeno — uma maneira limpa de evitar a poluição do espaço de nomes.

fun main() {
    val username = readUserConfig().let { config ->
        config.uppercase()
    }
    println(username)
}
fun readUserConfig() = "ada"

Noções básicas de run

run funciona como let, mas usa this em vez de it. É útil quando você quer chamar vários membros do receptor.

class Rect(val w: Int, val h: Int) {
    fun area() = w * h
    fun perimeter() = 2 * (w + h)
}
fun main() {
    val description = Rect(3, 4).run {
        "area=${area()}, perimeter=${perimeter()}"
    }
    println(description)
}

run como bloco independente

run { ... } (sem um receptor) executa o bloco e retorna o resultado — útil para agrupar cálculos.

fun main() {
    val result = run {
        val a = 10
        val b = 20
        a + b
    }
    println(result) // 30
}

let e run pelo estilo do receptor

Se o corpo da lambda acessa muitos membros do receptor, run evita it.. Se usa o receptor apenas uma ou duas vezes, let fica legível.

class User(val name: String, val email: String, val age: Int)
fun main() {
    val user = User("Ada", "ada@x.io", 35)
    // run: this-style
    val s1 = user.run { "$name <$email> age $age" }
    // let: it-style
    val s2 = user.let { "${it.name} <${it.email}> age ${it.age}" }
    println(s1); println(s2)
}

Combinando let e Elvis

A combinação de ?.let { ... } e ?: é um poderoso padrão de fluxo seguro contra nulos.

fun main() {
    val raw: String? = "  hello  "
    val cleaned = raw?.let { it.trim().uppercase() } ?: "(empty)"
    println(cleaned) // HELLO
}

run com configuração e resultado

Combine a configuração (via this) com um valor retornado em um único bloco.

class Connection {
    var host: String = ""
    fun connect() = "connected to $host"
}
fun main() {
    val status = Connection().run {
        host = "localhost"
        connect()
    }
    println(status)
}

Antipadrão: uso excessivo de let

Não envolva verificações simples de nulos em let quando um if for mais claro. Use funções de escopo onde elas realmente ajudarem.

fun main() {
    val name: String? = "Ada"
    // OK
    name?.let { println(it.length) }
    // Equivalent and clearer for trivial cases:
    if (name != null) println(name.length)
}

Verificação rápida

Qual função de escopo passa o receptor para a lambda como it AND retorna o resultado da lambda?

Recapitulação

let usa it e retorna o resultado da lambda — excelente para transformações seguras contra nulos e para limitar o escopo. run usa this e retorna o resultado da lambda — excelente quando você chama muitos membros do receptor. Ambas são ótimas para código no estilo de expressões.

Perguntas Frequentes

A aula “let e run: transformando e delimitando o escopo” é grátis?

Sim — o texto completo de “let e run: transformando e delimitando o escopo” é 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 e run: transformando e delimitando o escopo”?

Aplique let a transformações seguras contra nulos e run a computações locais. 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 2 de 4.

Quanto tempo leva a aula “let e run: transformando e delimitando o escopo”?

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. apply e with: configurando e retornando
  2. let e run: transformando e delimitando o escopo
  3. also: efeitos colaterais sem alterar o receptor
  4. Escolhendo a função de escopo certa: guia de decisão
← Voltar para Kotlin Academy