Kotlin Academy · Aula

Chamadas Seguras e Elvis

Operadores ?. e ?:

Aula 2 de 413 etapas

Chamadas Seguras e Elvis é 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.

Trabalhando com valores anuláveis de forma limpa

Escrever if (x != null) em todos os lugares torna o código prolixo. O Kotlin oferece dois operadores concisos para valores anuláveis:

a chamada segura ?.
o operador Elvis ?:

O operador de chamada segura

A chamada segura ?. chama um método ou lê uma propriedade somente se o valor não for nulo. Caso contrário, toda a expressão será avaliada como null.

Sem falha e sem verificação explícita.

fun main() {
    val name: String? = "Kotlin"
    println(name?.length)
}

Chamada segura em um valor nulo

Quando o receptor é null, a chamada segura interrompe a avaliação e retorna null em vez de lançar uma exceção.

Essa é a principal diferença em relação a uma chamada comum com ponto.

fun main() {
    val name: String? = null
    println(name?.length)
}

Encadeando chamadas seguras

As chamadas seguras podem ser encadeadas. Se qualquer elo da cadeia for null, todo o resultado se tornará null.

Isso evita verificações de nulo profundamente aninhadas.

fun main() {
    val text: String? = "hello world"
    val result = text?.uppercase()?.substring(0, 5)
    println(result)
}

O operador Elvis

O operador Elvis ?: fornece um valor alternativo quando o lado esquerdo é null.

Leia-o assim: use o valor da esquerda ou, caso contrário, o da direita.

fun main() {
    val name: String? = null
    val display = name ?: "Guest"
    println(display)
}

Elvis com um valor real

Se o lado esquerdo não for nulo, o operador Elvis simplesmente o retornará e ignorará o valor alternativo.

O valor alternativo só será usado quando o valor estiver ausente.

fun main() {
    val name: String? = "Sam"
    val display = name ?: "Guest"
    println(display)
}

Combinando chamada segura e Elvis

Esses operadores costumam ser usados juntos. Uma chamada segura pode produzir null, e o Elvis fornece um valor padrão.

Esse é um dos padrões mais comuns do Kotlin.

fun main() {
    val name: String? = null
    val length = name?.length ?: 0
    println(length)
}

Elvis para retorno antecipado

O lado direito do Elvis pode ser return ou throw. Essa é uma maneira limpa de sair antecipadamente quando um valor está ausente.

Se id for nulo, a função retornará imediatamente.

fun process(id: String?) {
    val safeId = id ?: return
    println("Processing " + safeId)
}

fun main() {
    process("A-100")
    process(null)
    println("done")
}

Chamada segura com let

Combine ?. com let para executar um bloco somente quando o valor não for nulo.

Dentro do bloco, it refere-se ao valor não nulo.

fun main() {
    val name: String? = "Kotlin"
    name?.let {
        println("Length is " + it.length)
    }
}

Números padrão com Elvis

O Elvis é útil para converter números anuláveis em valores padrão seguros antes de fazer operações aritméticas.

Aqui, uma contagem nula torna-se 0, para que os cálculos sempre funcionem.

fun main() {
    val count: Int? = null
    val total = (count ?: 0) + 5
    println(total)
}

Reunindo os conceitos

Juntos, esses operadores substituem verificações de nulo extensas:

?. chama somente quando o valor não é nulo
?: fornece um valor alternativo quando o valor é nulo
O encadeamento e let tornam fluxos complexos concisos

fun main() {
    val input: String? = null
    val name = input?.trim()?.uppercase() ?: "UNKNOWN"
    println(name)
}

Verificação rápida

Teste sua compreensão sobre chamadas seguras e Elvis.

Responda na aula interativa

Recapitulação

Você aprendeu os dois operadores essenciais para valores anuláveis:

Chamada segura ?. retorna nulo em vez de causar uma falha
Elvis ?: fornece um valor alternativo
Eles combinam perfeitamente com let e retornos antecipados

A seguir, você verá o operador !! e por que ele deve ser usado com cuidado.

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 “Chamadas Seguras e Elvis” é grátis?

Sim — o texto completo de “Chamadas Seguras e Elvis” é 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 “Chamadas Seguras e Elvis”?

Operadores ?. e ?: 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 “Chamadas Seguras e Elvis”?

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