Evitando null
Fundamentos de Option.
Evitando null é uma aula grátis de Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O problema com null
Em muitas linguagens, um valor ausente é representado por null. Porém, null causa a temida NullPointerException quando você se esquece de verificá-lo.
Scala oferece uma alternativa mais segura: o tipo Option.
O que é Option?
Option[A] representa um valor que pode ou não estar presente. Ele tem exatamente dois casos:
Some(value)quando existe um valorNonequando não há valor
O próprio tipo informa que um valor pode estar ausente.
object Main {
def main(args: Array[String]): Unit = {
val present: Option[Int] = Some(42)
val absent: Option[Int] = None
println(present)
println(absent)
}
}Criando Some
Envolva um valor existente em Some para indicar que ele está definitivamente presente.
object Main {
def main(args: Array[String]): Unit = {
val name: Option[String] = Some("Ada")
println(name)
}
}Representando ausência com None
None é o único valor usado quando não há nada presente. Ele funciona para qualquer tipo Option.
object Main {
def lookup(found: Boolean): Option[Int] =
if (found) Some(100) else None
def main(args: Array[String]): Unit = {
println(lookup(true))
println(lookup(false))
}
}Funções que podem falhar
Retornar Option torna explícita na assinatura do tipo a possibilidade de não haver resultado. Os chamadores não podem ignorá-la.
object Main {
def findUser(id: Int): Option[String] =
if (id == 1) Some("Grace") else None
def main(args: Array[String]): Unit = {
println(findUser(1))
println(findUser(2))
}
}Verificando com isDefined e isEmpty
isDefined informa se um Option é um Some, e isEmpty informa se ele é None.
object Main {
def main(args: Array[String]): Unit = {
val a: Option[Int] = Some(5)
val b: Option[Int] = None
println(a.isDefined)
println(b.isEmpty)
}
}Correspondência de padrões em um Option
Como Option é um ADT selado, você pode usar correspondência de padrões nele. Isso trata claramente tanto da presença quanto da ausência.
object Main {
def greet(name: Option[String]): String = name match {
case Some(n) => s"Hello, $n"
case None => "Hello, stranger"
}
def main(args: Array[String]): Unit = {
println(greet(Some("Bo")))
println(greet(None))
}
}Option a partir de valores anuláveis
Se precisar trabalhar com código que retorna null, envolva-o com Option(...). Isso converte null em None e qualquer valor real em Some.
object Main {
def main(args: Array[String]): Unit = {
val maybe = Option("data")
val nothing = Option(null)
println(maybe)
println(nothing)
}
}A biblioteca padrão retorna Option
Muitos métodos integrados já retornam Option em vez de arriscar erros. Por exemplo, List.headOption trata listas vazias com segurança.
object Main {
def main(args: Array[String]): Unit = {
val xs = List(1, 2, 3)
val empty = List.empty[Int]
println(xs.headOption)
println(empty.headOption)
}
}Por que usar Option em vez de null?
Option é melhor que null porque:
- Torna os valores ausentes visíveis no tipo
- Obriga os chamadores a tratar o caso de ausência
- Elimina NullPointerExceptions
- Permite composição com map, flatMap e compreensões for
Reunindo tudo
Uma pequena consulta que retorna Option e depois é tratada com segurança usando correspondência de padrões.
object Main {
val prices = Map("apple" -> 3, "pear" -> 5)
def priceOf(item: String): Option[Int] = prices.get(item)
def main(args: Array[String]): Unit = {
priceOf("apple") match {
case Some(p) => println(s"costs $p")
case None => println("not for sale")
}
println(priceOf("banana"))
}
}Verificação rápida
Teste sua compreensão sobre Option.
Recapitulação
Você aprendeu a evitar null com Option:
Option[A]éSome(value)ouNone- Isso torna explícita no tipo a possível ausência
- Verifique com
isDefined/isEmptyou use correspondência de padrões - Use
Option(x)para envolver valores anuláveis - Métodos da biblioteca, como
headOptioneMap.get, retornam Option
Perguntas Frequentes
A aula “Evitando null” é grátis?
Sim — o texto completo de “Evitando null” é 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 Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.
O que vou aprender em “Evitando null”?
Fundamentos de Option. Você pratica Scala for Backend Engineering & Functional Programming 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 Scala for Backend Engineering & Functional Programming?
Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming 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 “Evitando null”?
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 Scala for Backend Engineering & Functional Programming?
Sim. Cada aula de Scala for Backend Engineering & Functional Programming 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.