0Pricing
Scala for Backend Engineering & Functional Programming · Aula

Desestruturando tuplas

Extraia os valores novamente.

Desestruturando tuplas é uma aula grátis de Scala for Backend Engineering & Functional Programming 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 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.

Extraindo valores

Criar uma tupla é apenas metade da história. Para usar os valores que estão dentro dela, você precisa extraí-los.

O Scala oferece duas formas principais: acessadores numerados e desestruturação por padrão. Esta lição aborda ambas.

Acessando por posição

Cada elemento da tupla tem uma posição que pode ser lida com ._1, ._2 e assim por diante.

Observe que as posições começam em um, não em zero. Portanto, ._1 é o primeiro elemento.

val person = ("Alice", 30)
println(person._1)
println(person._2)

Usando acessadores no código

Os acessadores posicionais são úteis quando você precisa de apenas um elemento.

Aqui, lemos a idade de um par e adicionamos um a ela. Os acessadores retornam o tipo original do elemento, então os cálculos funcionam diretamente.

val record = ("Bob", 42)
val nextYear = record._2 + 1
println(nextYear)

Desestruturação com val

Ler ._1 e ._2 pode dificultar o entendimento. A desestruturação permite nomear cada elemento de uma só vez.

Este padrão de val associa name e age em uma única linha.

val (name, age) = ("Cara", 25)
println(name)
println(age)

Por que a desestruturação ajuda

Variáveis nomeadas são muito mais fáceis de ler do que posições numeradas.

Ao comparar age com person._2, a versão desestruturada deixa sua intenção evidente e evita erros de deslocamento de uma posição.

val (city, population) = ("Lyon", 500000)
println(s"$city has $population people")

Desestruturando três elementos

A desestruturação funciona para tuplas de qualquer tamanho, não apenas para pares.

Aqui, uma tupla de três elementos é descompactada em três variáveis nomeadas em uma única instrução.

val (id, label, active) = (7, "task", true)
println(id)
println(label)
println(active)

Ignorando com sublinhado

Às vezes, você quer apenas alguns dos valores. Use um sublinhado _ para ignorar uma posição.

Aqui, mantemos apenas o nome e ignoramos completamente a idade.

val (name, _) = ("Dana", 40)
println(name)

Desestruturando resultados de funções

Funções que retornam tuplas combinam naturalmente com a desestruturação.

Você pode nomear os dois valores retornados exatamente no ponto em que chama a função, tornando o resultado autoexplicativo.

def minMax(a: Int, b: Int) = (a min b, a max b)
val (low, high) = minMax(8, 3)
println(low)
println(high)

Trocando um par

Uma tupla de dois elementos tem um método swap integrado que inverte seus elementos.

Isso retorna um novo par com a ordem invertida, o que pode ser útil ocasionalmente.

val pair = ("a", 1)
println(pair.swap)

Desestruturação em for

Ao percorrer uma coleção de pares, você pode desestruturar dentro do cabeçalho do laço.

Cada par é descompactado automaticamente em key e value a cada iteração.

val pairs = List(("a", 1), ("b", 2))
for ((key, value) <- pairs) println(s"$key=$value")

Os tipos são preservados

A desestruturação nunca perde informações de tipo. Cada variável nomeada mantém o tipo exato de sua posição.

Assim, em val (n, age) = ("Eve", 33), n é uma String e age é um Int, prontos para uso com segurança de tipos.

val (n, age) = ("Eve", 33)
println(n.length)
println(age * 2)

Verificação rápida

Teste o que você aprendeu sobre a desestruturação de tuplas.

Recapitulação

Você pode extrair valores de tuplas com acessadores posicionais como ._1 (baseados em um) ou, de forma mais clara, com desestruturação, como em val (a, b) = pair.

O sublinhado ignora posições indesejadas, a desestruturação funciona em laços for e os tipos são sempre preservados. A seguir, você explorará intervalos.

Perguntas Frequentes

A aula “Desestruturando tuplas” é grátis?

Sim — o texto completo de “Desestruturando tuplas” é 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 “Desestruturando tuplas”?

Extraia os valores novamente. 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 2 de 4.

Quanto tempo leva a aula “Desestruturando tuplas”?

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

  1. Criando tuplas
  2. Desestruturando tuplas
  3. Construindo intervalos
  4. Intervalos em laços
← Voltar para Scala for Backend Engineering & Functional Programming