Introdução
Os tuplos agrupam vários valores num único valor composto.
Ao contrário dos arrays, os valores de um tuplo não precisam de partilhar o mesmo tipo, e o tamanho de um tuplo é fixo depois de criado.
Cria um tuplo colocando valores separados por vírgulas entre parênteses:
let order = ("biscuits", 2.99, 3)
Também podes especificar anotações de tipo explicitamente:
let order: (String, Double, Int) = ("biscuits", 2.99, 3)
Para extrair elementos individuais de um tuplo sem nomes, usa a sintaxe de índices a partir do zero (.0, .1, etc.):
let item = order.0 // "biscuits"
let quantity = order.2 // 3
Podes dar nomes a elementos individuais do tuplo ao defini-lo:
let order = (item: "biscuits", price: 2.99, quantity: 3)
Dar nomes aos elementos torna o código mais legível e permite-te aceder aos elementos com a notação de ponto e as respetivas etiquetas:
let item = order.item // "biscuits"
let quantity = order.quantity // 3
Também podes 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 tuplos
Se um tuplo for declarado como variável (var), podes atualizar os seus elementos:
var order = ("biscuits", 2.99, 3)
order.0 = "cookies"
order.1 = 1.99
order.2 = 5
print(order)
// Prints ("cookies", 1.99, 5)
Devolver vários valores
Embora as funções Swift só possam devolver um único valor, devolver um tuplo permite-te agrupar e devolver 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"
Decomposição de tuplos
Podes decompor (desempacotar) os valores de um tuplo em constantes ou variáveis separadas:
let order = ("biscuits", 2.99, 3)
let (item, price, quantity) = order
print(item) // Prints "biscuits"
A decomposição de tuplos também funciona diretamente em ciclos 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
És um elfo a trabalhar na divisão de logística do Pai Natal e o chefe deu-te um par de tarefas para melhorar o software do sistema.
1. Obter o nome do brinquedo
O sistema tem de conseguir obter o nome de um brinquedo a partir da base de dados.
A base de dados é composta por tuplas do tipo (name: String, quantity: Int).
Implementa 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 brinquedo novo à base de dados
O mercado dos brinquedos é rápido e está sempre a mudar: o que é popular muda muito depressa.
Por isso, é precisa uma função que crie um brinquedo novo.
Implementa 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 da oficina do Pai Natal estão constantemente a fazer mais brinquedos, e o Pai Natal tem de manter o controlo da quantidade de cada brinquedo.
Para isso, o sistema tem de conseguir atualizar a quantidade de um brinquedo na base de dados.
Implementa 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.
Podes assumir que o brinquedo já está na base de dados e que não precisas de 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 Pai Natal quer conseguir categorizar os brinquedos na base de dados.
Assim, consegue encontrar facilmente os brinquedos quando precisa de fazer uma entrega, e consegue ordenar os brinquedos na base de dados.
No entanto, quando o sistema foi implementado pela primeira vez, a chave de categoria foi esquecida.
Agora, o sistema tem de conseguir adicionar uma chave de categoria a um brinquedo na base de dados.
Implementa 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.
Podes assumir que o brinquedo já está na base de dados e que não precisas de verificar isso.
Podes também assumir que o brinquedo ainda não tem nenhuma chave de categoria.
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
