Introduction
Les tuples permettent de regrouper plusieurs valeurs en une seule valeur composée.
Contrairement aux tableaux, les valeurs d'un tuple n'ont pas besoin d'être du même type, et la taille d'un tuple est fixe une fois qu'il est créé.
Pour créer un tuple, on place les valeurs entre parenthèses, séparées par des virgules :
let order = ("biscuits", 2.99, 3)
On peut aussi préciser explicitement les annotations de type :
let order: (String, Double, Int) = ("biscuits", 2.99, 3)
Pour extraire les éléments individuels d'un tuple non nommé, on utilise la syntaxe d'indice commençant à 0 (.0, .1, etc.) :
let item = order.0 // "biscuits"
let quantity = order.2 // 3
Tuples nommés
On peut donner un nom à chacun des éléments d'un tuple au moment de le définir :
let order = (item: "biscuits", price: 2.99, quantity: 3)
Nommer les éléments rend le code plus lisible et permet d'accéder aux éléments par leur étiquette, avec la notation pointée :
let item = order.item // "biscuits"
let quantity = order.quantity // 3
On peut aussi inclure les noms des éléments dans l'annotation de type :
let order: (item: String, price: Double, quantity: Int) = (item: "biscuits", price: 2.99, quantity: 3)
Modifie un tuple
Si un tuple est déclaré comme variable (var), on peut mettre à jour ses éléments :
var order = ("biscuits", 2.99, 3)
order.0 = "cookies"
order.1 = 1.99
order.2 = 5
print(order)
// Prints ("cookies", 1.99, 5)
Plusieurs valeurs de retour
Bien que les fonctions Swift ne puissent renvoyer qu'une seule valeur, renvoyer un tuple permet de regrouper plusieurs valeurs et d'en renvoyer plusieurs depuis une fonction :
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"
Décomposition d'un tuple
On peut décomposer (extraire) les valeurs d'un tuple en constantes ou variables distinctes :
let order = ("biscuits", 2.99, 3)
let (item, price, quantity) = order
print(item) // Prints "biscuits"
La décomposition de tuple fonctionne aussi directement dans les boucles 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)")
}
Instructions
Tu es un elfe qui travaille dans la division logistique du père Noël et le patron t'a confié deux tâches pour mettre à jour le logiciel du système.
1. Récupère le nom du jouet
Le système doit pouvoir récupérer le nom d'un jouet depuis la base de données.
La base de données est constituée de tuples de type (name: String, quantity: Int).
Implémente la fonction getName(_:), qui prend un argument contenant un tuple de type (name: String, quantity: Int).
let toy = (name: "Doll", quantity: 10)
getName(toy)
// Returns "Doll"
2. Ajoute un nouveau jouet à la base de données
Le marché du jouet est un marché rapide et changeant : ce qui est populaire évolue très vite.
Il faut donc une fonction qui crée un nouveau jouet.
Implémente la fonction createToy(name:amount:), qui prend un argument name contenant le nom du jouet, et amount contenant la quantité du jouet.
createToy(name: "Doll", amount: 10)
// Returns (name: "Doll", amount: 10)
3. Mets à jour la quantité d'un jouet
Les elfes de l'atelier du père Noël fabriquent sans cesse de nouveaux jouets, et le père Noël doit suivre la quantité de chaque jouet.
Pour cela, le système doit pouvoir mettre à jour la quantité d'un jouet dans la base de données.
Implémente la fonction updateQuantity(_:toy:Amount:), qui prend les arguments :
-
toys qui contient un tableau de tuples de type (name: String, quantity: Int).
-
toy qui contient le nom du jouet à mettre à jour.
-
amount qui contient la nouvelle quantité du jouet.
Tu peux supposer que le jouet est déjà dans la base de données, et tu n'as pas besoin de le vérifier.
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. Ajoute une clé de catégorie à un jouet
Le père Noël veut pouvoir catégoriser les jouets de la base de données.
Ainsi, il peut facilement retrouver les jouets quand il doit faire une livraison, et trier les jouets de la base de données.
Cependant, lors de la première implémentation du système, la clé de catégorie a été oubliée.
Maintenant, le système doit pouvoir ajouter une clé de catégorie à un jouet dans la base de données.
Implémente la fonction addCategory(_:category:), qui prend les arguments :
-
toys qui contient un tableau de tuples de type (name: String, quantity: Int).
-
category qui contient la clé de catégorie à ajouter aux jouets.
Tu peux supposer que le jouet est déjà dans la base de données, et tu n'as pas besoin de le vérifier.
Tu peux aussi supposer que le jouet n'a pas déjà de clé de catégorie.
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")]
Exercice d'apprentissage
