Kotlin Academy · Aula

let e run

Opere sobre objetos

Aula 1 de 413 etapas

let e run é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 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.

O Que São Funções de Escopo

O Kotlin oferece cinco funções de escopo: let, run, with, apply e also. Elas permitem executar um bloco de código sobre um objeto dentro de um escopo temporário.

Você faz referência ao objeto como it ou this.
O bloco retorna o próprio objeto ou o resultado da função lambda.

Nesta lição, o foco está em let e run.

A função let

let executa um bloco no qual o objeto fica disponível como it e retorna o resultado da lambda.

É excelente para executar código somente quando um valor não é nulo e para transformar um valor em outra coisa.

fun main() {
    val name = "Alice"
    val length = name.let {
        println("Name is $it")
        it.length
    }
    println("Length: $length")
}

let com valores anuláveis

O uso mais comum de let é com o operador de chamada segura ?. O bloco é executado somente quando o valor não é nulo.

fun main() {
    val name: String? = "Bob"
    name?.let {
        println("Hello, $it")
    }
    val empty: String? = null
    empty?.let {
        println("This never prints")
    }
    println("Done")
}

Renomeando it em let

Dentro de let, você pode renomear it para um nome significativo declarando um parâmetro de lambda.

fun main() {
    val price = 100
    price.let { amount ->
        println("The amount is $amount")
    }
}

A função run

run executa um bloco no qual o objeto fica disponível como this e retorna o resultado da lambda.

Use-a quando quiser acessar membros diretamente, sem um prefixo.

fun main() {
    val text = "Kotlin"
    val upper = text.run {
        println("Length is $length")
        uppercase()
    }
    println(upper)
}

run sem um receptor

run também pode ser chamado sem um objeto. Ele simplesmente executa um bloco e retorna o resultado dele. Isso é útil para agrupar instruções e calcular um valor.

fun main() {
    val result = run {
        val a = 5
        val b = 10
        a + b
    }
    println("Result: $result")
}

it versus this

A principal diferença entre let e run é a forma como eles fazem referência ao objeto:

let usa it (um parâmetro).
run usa this (um receptor, geralmente implícito).

Ambos retornam o resultado da última expressão no bloco.

fun main() {
    val word = "hi"
    val a = word.let { it.length }
    val b = word.run { length }
    println("$a $b")
}

Encadeando com let

Como let retorna o resultado da lambda, você pode encadear chamadas e transformar um valor passo a passo.

fun main() {
    val number = 4
    val output = number
        .let { it * 2 }
        .let { it + 1 }
    println(output)
}

run para verificações de nulos e cálculos

Assim como let, run funciona com chamadas seguras. Ele combina uma verificação de nulo com o acesso a membros em um único bloco.

fun main() {
    val message: String? = "Welcome"
    val length = message?.run {
        println(this)
        length
    }
    println("Length: $length")
}

Retornando tipos diferentes

Ambas as funções podem retornar um tipo diferente do objeto. O tipo de retorno é determinado pelo valor avaliado na última linha.

fun main() {
    val n = 10
    val label: String = n.let { "Value is $it" }
    println(label)
}

Quando usar let ou run

Use let para operações seguras para nulos e transformações de valores nas quais it seja uma referência clara.

Use run quando quiser chamar vários membros do objeto e calcular um resultado, com this fornecendo acesso direto.

Verificação rápida

Teste sua compreensão de let e run.

Responda na aula interativa

Recapitulação

Você aprendeu as duas funções de escopo que retornam resultados:

let expõe o objeto como it e retorna o resultado da lambda, sendo ideal para transformações seguras para nulos.
run expõe o objeto como this e retorna o resultado da lambda, sendo ideal para agrupar o acesso a membros.

Em seguida, você aprenderá a configurar objetos com apply e adicionar efeitos colaterais com also.

Grátis para começar

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

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “let e run” é grátis?

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

Opere sobre objetos 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 1 de 4.

Quanto tempo leva a aula “let e run”?

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