Introduzione
Le tuple raggruppano più valori in un unico valore composto.
A differenza degli array, i valori di una tupla non devono essere dello stesso tipo, e la dimensione di una tupla è fissa una volta creata.
Per creare una tupla, racchiudi tra parentesi dei valori separati da virgole:
let order = ("biscuits", 2.99, 3)
Puoi anche specificare le annotazioni di tipo in modo esplicito:
let order: (String, Double, Int) = ("biscuits", 2.99, 3)
Per estrarre i singoli elementi da una tupla senza nome, usa la sintassi dell'indice a base zero (.0, .1, ecc.):
let item = order.0 // "biscuits"
let quantity = order.2 // 3
Tuple con nome
Puoi dare un nome ai singoli elementi di una tupla quando la definisci:
let order = (item: "biscuits", price: 2.99, quantity: 3)
Dare un nome agli elementi rende il codice più leggibile e ti permette di accedere agli elementi usando la notazione puntata con le loro etichette:
let item = order.item // "biscuits"
let quantity = order.quantity // 3
Puoi anche includere i nomi degli elementi nell'annotazione di tipo:
let order: (item: String, price: Double, quantity: Int) = (item: "biscuits", price: 2.99, quantity: 3)
Modificare le tuple
Se una tupla è dichiarata come variabile (var), puoi aggiornarne gli elementi:
var order = ("biscuits", 2.99, 3)
order.0 = "cookies"
order.1 = 1.99
order.2 = 5
print(order)
// Prints ("cookies", 1.99, 5)
Restituire più valori
Sebbene le funzioni Swift possano restituire un solo valore, restituire una tupla ti permette di raggruppare e restituire più valori da una funzione:
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"
Scomposizione delle tuple
Puoi scomporre (estrarre) i valori di una tupla in costanti o variabili separate:
let order = ("biscuits", 2.99, 3)
let (item, price, quantity) = order
print(item) // Prints "biscuits"
La scomposizione delle tuple funziona anche direttamente nei cicli 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)")
}
Istruzioni
Sei un elfo che lavora nella divisione logistica di Babbo Natale e il capo ti ha affidato un paio di compiti per aggiornare il software del sistema.
1. Ottenere il nome del giocattolo
Il sistema deve essere in grado di ottenere il nome di un giocattolo dal database.
Il database è fatto di tuple di tipo (name: String, quantity: Int).
Implementa la funzione getName(_:), che prende un argomento contenente una tupla di tipo (name: String, quantity: Int).
let toy = (name: "Doll", quantity: 10)
getName(toy)
// Returns "Doll"
2. Aggiungere un nuovo giocattolo al database
Il mercato dei giocattoli è un mercato rapido e in continuo cambiamento: ciò che è popolare cambia molto velocemente.
Per questo serve una funzione che crei un nuovo giocattolo.
Implementa la funzione createToy(name:amount:), che prende un argomento name che contiene il nome del giocattolo e amount che contiene la quantità del giocattolo.
createToy(name: "Doll", amount: 10)
// Returns (name: "Doll", amount: 10)
3. Aggiornare la quantità di un giocattolo
Gli elfi nella bottega di Babbo Natale producono continuamente nuovi giocattoli e Babbo Natale deve tenere traccia della quantità di ogni giocattolo.
Per farlo, il sistema deve essere in grado di aggiornare la quantità di un giocattolo nel database.
Implementa la funzione updateQuantity(_:toy:Amount:), che prende gli argomenti:
-
toys che contiene un array di tuple di tipo (name: String, quantity: Int).
-
toy che contiene il nome del giocattolo da aggiornare.
-
amount che contiene la nuova quantità del giocattolo.
Puoi presumere che il giocattolo sia già nel database e non devi verificarlo.
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. Aggiungere una chiave di categoria a un giocattolo
Babbo Natale vuole poter categorizzare i giocattoli nel database.
In questo modo può trovarli facilmente quando deve fare una consegna e può ordinare i giocattoli nel database.
Tuttavia, quando il sistema è stato implementato per la prima volta, la chiave di categoria è stata dimenticata.
Ora il sistema deve essere in grado di aggiungere una chiave di categoria a un giocattolo nel database.
Implementa la funzione addCategory(_:category:), che prende gli argomenti:
-
toys che contiene un array di tuple di tipo (name: String, quantity: Int).
-
category che contiene la chiave di categoria da aggiungere ai giocattoli.
Puoi presumere che il giocattolo sia già nel database e non devi verificarlo.
Puoi anche presumere che nel giocattolo non ci sia già una chiave di 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")]
Esercizio di apprendimento
