Introdução
Tuplas agrupam vários valores em um único valor composto.
Diferente dos arrays, os valores de uma tupla não precisam ser do mesmo tipo, e o tamanho de uma tupla é fixo depois de criada.
Para criar uma tupla, coloque valores separados por vírgula entre parênteses:
let order = ("biscuits", 2.99, 3)
Você também pode especificar as anotações de tipo explicitamente:
let order: (String, Double, Int) = ("biscuits", 2.99, 3)
Para extrair elementos individuais de uma tupla sem nome, use a sintaxe de índice começando em zero (.0, .1, etc.):
let item = order.0 // "biscuits"
let quantity = order.2 // 3
Tuplas nomeadas
Você pode dar nomes aos elementos de uma tupla no momento em que a define:
let order = (item: "biscuits", price: 2.99, quantity: 3)
Dar nomes aos elementos deixa o código mais legível e permite acessar os elementos com a notação de ponto e os respectivos rótulos:
let item = order.item // "biscuits"
let quantity = order.quantity // 3
Você também pode incluir os nomes dos elementos na anotação de tipo:
let order: (item: String, price: Double, quantity: Int) = (item: "biscuits", price: 2.99, quantity: 3)
Modificar tuplas
Se uma tupla for declarada como variável (var), você pode atualizar os elementos dela:
var order = ("biscuits", 2.99, 3)
order.0 = "cookies"
order.1 = 1.99
order.2 = 5
print(order)
// Prints ("cookies", 1.99, 5)
Retornar vários valores
Embora as funções em Swift só possam retornar um único valor, retornar uma tupla permite empacotar e retornar vários valores a partir de uma função:
func divide(_ dividend: Int, by divisor: Int) -> (quotient: Int, remainder: Int) {
let quotient = dividend / divisor
let remainder = dividend % divisor
return (quotient, remainder)
}
let result = divide(14, by: 4)
print("Quotient: \(result.quotient), Remainder: \(result.remainder)")
// Prints "Quotient: 3, Remainder: 2"
Desestruturação de tuplas
Você pode desestruturar (desempacotar) os valores de uma tupla em constantes ou variáveis separadas:
let order = ("biscuits", 2.99, 3)
let (item, price, quantity) = order
print(item) // Prints "biscuits"
A desestruturação de tuplas também funciona diretamente em laços for-in:
let orders = [("biscuits", 2.99, 3), ("cookies", 1.99, 5)]
for (item, price, quantity) in orders {
print("Item: \(item), Price: \(price), Quantity: \(quantity)")
}
Instruções
Você é um elfo que trabalha na divisão de logística do Papai Noel e recebeu duas tarefas do chefe para atualizar o software do sistema.
1. Obter o nome do brinquedo
O sistema precisa conseguir obter o nome de um brinquedo do banco de dados.
O banco de dados é composto de tuplas do tipo (name: String, quantity: Int).
Implemente a função getName(_:), que recebe um argumento que contém uma tupla do tipo (name: String, quantity: Int).
let toy = (name: "Doll", quantity: 10)
getName(toy)
// Returns "Doll"
2. Adicionar um novo brinquedo ao banco de dados
O mercado de brinquedos é um mercado rápido e em constante mudança: o que é popular muda muito rapidamente.
Por isso, é necessária uma função que crie um novo brinquedo.
Implemente a função createToy(name:amount:), que recebe um argumento name que contém o nome do brinquedo, e amount que contém a quantidade do brinquedo.
createToy(name: "Doll", amount: 10)
// Returns (name: "Doll", amount: 10)
3. Atualizar a quantidade de um brinquedo
Os elfos na oficina do Papai Noel estão constantemente fazendo mais brinquedos, e o Papai Noel precisa acompanhar a quantidade de cada brinquedo.
Para isso, o sistema precisa conseguir atualizar a quantidade de um brinquedo no banco de dados.
Implemente a função updateQuantity(_:toy:Amount:), que recebe os argumentos:
-
toys que contém um array de tuplas do tipo (name: String, quantity: Int).
-
toy que contém o nome do brinquedo a atualizar.
-
amount que contém a nova quantidade do brinquedo.
Você pode assumir que o brinquedo já está no banco de dados e não precisa verificar isso.
let toys = [(name: "Doll", quantity: 10), (name: "Car", quantity: 5), (name: "Train", quantity: 3)]
updateQuantity(toys, toy: "Doll", amount: 15)
// Returns [(name: "Doll", quantity: 15), (name: "Car", quantity: 5), (name: "Train", quantity: 3)]
4. Adicionar uma chave de categoria a um brinquedo
O Papai Noel quer conseguir categorizar os brinquedos no banco de dados.
Isso permite que ele encontre os brinquedos facilmente quando precisar fazer uma entrega e consiga ordená-los no banco de dados.
No entanto, quando o sistema foi implementado pela primeira vez, a chave de categoria foi esquecida.
Agora, o sistema precisa conseguir adicionar uma chave de categoria a um brinquedo no banco de dados.
Implemente a função addCategory(_:category:), que recebe os argumentos:
-
toys que contém um array de tuplas do tipo (name: String, quantity: Int).
-
category que contém a chave de categoria a adicionar aos brinquedos.
Você pode assumir que o brinquedo já está no banco de dados e não precisa verificar isso.
Você também pode assumir que ainda não há uma chave de categoria no brinquedo.
let toys = [(name: "Car", quantity: 5), (name: "Train", quantity: 3)]
addCategory(toys, category: "Vehicle")
// Returns [(name: "Car", quantity: 5, category: "Vehicle"), (name: "Train", quantity: 3, category: "Vehicle")]
Exercício de aprendizagem
