Scala for Backend Engineering & Functional Programming · Aula

Desconstrução

Extraia dados.

Desconstrução é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 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 é desconstrução?

Desconstrução (também chamada de desestruturação) significa extrair as partes de uma estrutura de dados diretamente em um padrão.

Em vez de chamar métodos de acesso, você descreve a forma e nomeia as partes desejadas.

Desconstruindo uma tupla

Uma tupla agrupa vários valores. Você pode separá-los em uma única associação escrevendo os nomes entre parênteses.

object Main {
  def main(args: Array[String]): Unit = {
    val pair = ("Ada", 1815)
    val (name, year) = pair
    println(s"$name was born in $year")
  }
}

Tuplas em match

Você pode desconstruir uma tupla dentro de um match, nomeando ou verificando cada componente.

object Main {
  def quadrant(p: (Int, Int)): String = p match {
    case (0, 0) => "origin"
    case (x, 0) => s"on x-axis at $x"
    case (0, y) => s"on y-axis at $y"
    case (x, y) => s"point ($x, $y)"
  }
  def main(args: Array[String]): Unit = {
    println(quadrant((0, 0)))
    println(quadrant((3, 0)))
    println(quadrant((2, 5)))
  }
}

Desconstruindo o primeiro elemento de uma lista

O operador :: (cons) divide uma lista em seu primeiro elemento (cabeça) e o restante (cauda).

O padrão head :: tail corresponde a qualquer lista não vazia.

object Main {
  def first(xs: List[Int]): String = xs match {
    case head :: tail => s"head=$head, rest=$tail"
    case Nil          => "empty"
  }
  def main(args: Array[String]): Unit = {
    println(first(List(10, 20, 30)))
    println(first(Nil))
  }
}

Correspondência com formas exatas de listas

Você pode fazer correspondência com listas de um comprimento específico listando seus elementos, como List(a, b) para exatamente dois itens.

object Main {
  def shape(xs: List[Int]): String = xs match {
    case List()        => "none"
    case List(a)       => s"one: $a"
    case List(a, b)    => s"two: $a, $b"
    case _             => "many"
  }
  def main(args: Array[String]): Unit = {
    println(shape(List()))
    println(shape(List(1)))
    println(shape(List(1, 2)))
    println(shape(List(1, 2, 3)))
  }
}

Recursão com cabeça e cauda

Separar a cabeça da cauda permite fazer uma recursão simples sobre uma lista.

Aqui somamos uma lista adicionando a cabeça à soma da cauda.

object Main {
  def sum(xs: List[Int]): Int = xs match {
    case Nil          => 0
    case head :: tail => head + sum(tail)
  }
  def main(args: Array[String]): Unit = {
    println(sum(List(1, 2, 3, 4)))
  }
}

Desconstruindo estruturas aninhadas

Os padrões podem ser aninhados. Você pode desconstruir uma tupla dentro de uma lista ou uma lista dentro de uma tupla, tudo de uma vez.

object Main {
  def main(args: Array[String]): Unit = {
    val data = List(("a", 1), ("b", 2))
    data match {
      case (key, value) :: _ => println(s"first key=$key value=$value")
      case Nil               => println("empty")
    }
  }
}

Ignorando partes com _

Use _ para os componentes que não são importantes. Assim, os padrões permanecem concentrados nos dados de que você realmente precisa.

object Main {
  def main(args: Array[String]): Unit = {
    val triple = (1, 2, 3)
    val (_, middle, _) = triple
    println(s"middle = $middle")
  }
}

Associando os dois primeiros e mantendo o restante

Você pode nomear os primeiros elementos e capturar tudo o que vem depois com um padrão de cauda.

object Main {
  def main(args: Array[String]): Unit = {
    val xs = List(1, 2, 3, 4, 5)
    xs match {
      case a :: b :: rest => println(s"a=$a b=$b rest=$rest")
      case _              => println("too short")
    }
  }
}

Por que usar desconstrução?

A desconstrução torna o acesso aos dados:

Declarativo: você descreve a forma, não as etapas
Seguro: a estrutura é verificada durante a extração
Conciso: vários valores são associados em um único padrão

Ela se torna ainda mais poderosa com classes de caso.

Reunindo tudo

Este exemplo desconstrói uma lista de tuplas e reage à sua forma.

object Main {
  def report(scores: List[(String, Int)]): String = scores match {
    case Nil                  => "no scores"
    case (name, pts) :: Nil   => s"only $name with $pts"
    case (name, pts) :: rest  => s"top $name=$pts plus ${rest.size} more"
  }
  def main(args: Array[String]): Unit = {
    println(report(Nil))
    println(report(List(("Ann", 90))))
    println(report(List(("Ann", 90), ("Bo", 80))))
  }
}

Verificação rápida

Teste sua compreensão de desconstrução.

Recapitulação

Você aprendeu a desconstruir dados em padrões:

As tuplas são divididas com (a, b)
As listas são divididas com head :: tail ou formas exatas como List(a, b)
Nil corresponde à lista vazia
Use _ para ignorar partes; aninhe padrões para estruturas profundas
A divisão entre cabeça e cauda permite uma recursão simples

Perguntas Frequentes

A aula “Desconstrução” é grátis?

Sim — o texto completo de “Desconstrução” é 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 “Desconstrução”?

Extraia dados. 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 4 de 4.

Quanto tempo leva a aula “Desconstrução”?

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.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming