Expressões match
Faça ramificações pela forma.
Expressões match é 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 que é match?
match é uma poderosa construção de ramificação do Scala. Você fornece um valor e uma série de padrões case, e ele executa o primeiro ramo correspondente.
Pense nele como uma versão mais poderosa e baseada em expressões de uma instrução switch.
Sintaxe básica
Você escreve value match { case pattern => result }. Cada case define um padrão e o código a ser executado quando houver correspondência.
Como match é uma expressão, o conjunto inteiro retorna um valor.
object Main {
def main(args: Array[String]): Unit = {
val n = 2
val word = n match {
case 1 => "one"
case 2 => "two"
case 3 => "three"
}
println(word)
}
}O caso curinga
O sublinhado _ é um curinga que corresponde a qualquer coisa. Use-o como padrão abrangente no final.
Sem ele, um valor sem correspondência lança um MatchError em tempo de execução.
object Main {
def main(args: Array[String]): Unit = {
val n = 9
val word = n match {
case 1 => "one"
case 2 => "two"
case _ => "many"
}
println(word)
}
}Correspondendo strings
Os padrões não se limitam a números. Você pode fazer a correspondência diretamente com literais de string.
object Main {
def main(args: Array[String]): Unit = {
val cmd = "start"
val msg = cmd match {
case "start" => "Starting up"
case "stop" => "Shutting down"
case _ => "Unknown command"
}
println(msg)
}
}match retorna um valor
Como cada ramo produz um valor, você pode atribuir o resultado de match a um val ou usá-lo diretamente.
Isso mantém o código limpo e evita variáveis mutáveis.
object Main {
def main(args: Array[String]): Unit = {
val light = "red"
println(s"Action: " + (light match {
case "red" => "stop"
case "green" => "go"
case _ => "caution"
}))
}
}Combinando casos
Você pode fazer a correspondência de vários valores em um único caso usando | (a barra vertical). Todos os valores listados levam ao mesmo ramo.
object Main {
def main(args: Array[String]): Unit = {
val day = "Sat"
val kind = day match {
case "Sat" | "Sun" => "weekend"
case _ => "weekday"
}
println(kind)
}
}match em uma função
Um padrão comum é tornar todo o corpo da função uma única expressão match. O resultado da correspondência se torna o valor de retorno.
object Main {
def describe(n: Int): String = n match {
case 0 => "zero"
case 1 => "one"
case _ => "other"
}
def main(args: Array[String]): Unit = {
println(describe(0))
println(describe(5))
}
}Vinculando o valor inteiro
Você pode vincular o valor correspondente a um nome no caso curinga usando case other =>. Então, você pode usar other nesse ramo.
object Main {
def main(args: Array[String]): Unit = {
val n = 42
val result = n match {
case 0 => "nothing"
case other => s"got $other"
}
println(result)
}
}A ordem importa
Os casos são testados de cima para baixo, e a primeira correspondência vence. Coloque os padrões mais específicos antes dos mais gerais.
Um curinga colocado cedo demais ocultaria os casos abaixo dele.
object Main {
def main(args: Array[String]): Unit = {
val n = 1
val msg = n match {
case 1 => "specific one"
case _ => "anything else"
}
println(msg)
}
}Por que usar match?
A correspondência de padrões é fundamental em Scala porque:
- É clara para ramificações com várias alternativas
- Retorna um valor como expressão
- Escala para tipos, estruturas de dados e guardas
- Pode ter sua completude verificada pelo compilador
Reunindo tudo
Aqui está um pequeno classificador usando literais, um caso combinado e um caso padrão.
object Main {
def grade(score: Int): String = score match {
case 10 | 9 => "excellent"
case 8 | 7 => "good"
case _ => "keep trying"
}
def main(args: Array[String]): Unit = {
println(grade(9))
println(grade(7))
println(grade(3))
}
}Verificação rápida
Teste sua compreensão das expressões match.
Recapitulação
Você aprendeu os fundamentos de match:
- A sintaxe é
value match { case pattern => result } _é o curinga que captura qualquer caso- Combine valores com
| matché uma expressão que retorna um valor- Os casos são testados de cima para baixo; a primeira correspondência vence
Perguntas Frequentes
A aula “Expressões match” é grátis?
Sim — o texto completo de “Expressões match” é 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 “Expressões match”?
Faça ramificações pela forma. 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 “Expressões match”?
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.