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
- Criando tuplas
- Desestruturando tuplas
- Construindo intervalos
- Intervalos em laços