Einführung
Tupel fassen mehrere Werte zu einem einzigen zusammengesetzten Wert zusammen.
Anders als bei Arrays müssen die Werte in einem Tupel nicht denselben Typ haben, und die Größe eines Tupels ist nach dem Erstellen festgelegt.
Du erstellst ein Tupel, indem du kommagetrennte Werte in runde Klammern setzt:
let order = ("biscuits", 2.99, 3)
Du kannst Typannotationen auch explizit angeben:
let order: (String, Double, Int) = ("biscuits", 2.99, 3)
Um einzelne Elemente aus einem unbenannten Tupel zu extrahieren, verwendest du die Indexsyntax mit Nullbasis (.0, .1 usw.):
let item = order.0 // "biscuits"
let quantity = order.2 // 3
Benannte Tupel
Du kannst einzelnen Tupelelementen beim Definieren des Tupels Namen geben:
let order = (item: "biscuits", price: 2.99, quantity: 3)
Benannte Elemente machen den Code lesbarer und du kannst mit der Punktnotation über ihre Bezeichnungen auf die Elemente zugreifen:
let item = order.item // "biscuits"
let quantity = order.quantity // 3
Du kannst Elementnamen auch in die Typannotation aufnehmen:
let order: (item: String, price: Double, quantity: Int) = (item: "biscuits", price: 2.99, quantity: 3)
Tupel verändern
Wenn ein Tupel als Variable (var) deklariert ist, kannst du seine Elemente ändern:
var order = ("biscuits", 2.99, 3)
order.0 = "cookies"
order.1 = 1.99
order.2 = 5
print(order)
// Prints ("cookies", 1.99, 5)
Mehrere Werte zurückgeben
Swift-Funktionen können nur einen einzigen Wert zurückgeben. Wenn du ein Tupel zurückgibst, kannst du jedoch mehrere Werte bündeln und mehrere Werte aus einer Funktion zurückgeben:
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"
Tupel zerlegen
Du kannst die Werte eines Tupels in einzelne Konstanten oder Variablen zerlegen (entpacken):
let order = ("biscuits", 2.99, 3)
let (item, price, quantity) = order
print(item) // Prints "biscuits"
Das Zerlegen von Tupeln funktioniert auch direkt in for-in-Schleifen:
let orders = [("biscuits", 2.99, 3), ("cookies", 1.99, 5)]
for (item, price, quantity) in orders {
print("Item: \(item), Price: \(price), Quantity: \(quantity)")
}
Anleitung
Du bist ein Elf, der in der Logistikabteilung des Weihnachtsmanns arbeitet, und hast von deinem Chef zwei Aufgaben bekommen, um die Software des Systems zu verbessern.
1. Ermittle den Namen des Spielzeugs
Das System muss den Namen eines Spielzeugs aus der Datenbank auslesen können.
Die Datenbank besteht aus Tupeln vom Typ (name: String, quantity: Int).
Implementiere die Funktion getName(_:), die ein Argument entgegennimmt, das ein Tupel vom Typ (name: String, quantity: Int) enthält.
let toy = (name: "Doll", quantity: 10)
getName(toy)
// Returns "Doll"
2. Füge ein neues Spielzeug zur Datenbank hinzu
Der Spielzeugmarkt ist schnelllebig, und was beliebt ist, ändert sich sehr schnell.
Deshalb wird eine Funktion benötigt, die ein neues Spielzeug erstellt.
Implementiere die Funktion createToy(name:amount:), die das Argument name, das den Namen des Spielzeugs enthält, und amount, das die Anzahl des Spielzeugs enthält, entgegennimmt.
createToy(name: "Doll", amount: 10)
// Returns (name: "Doll", amount: 10)
3. Aktualisiere die Anzahl eines Spielzeugs
Die Elfen in der Werkstatt des Weihnachtsmanns stellen ständig neue Spielzeuge her, und der Weihnachtsmann muss die Anzahl jedes Spielzeugs im Blick behalten.
Dazu muss das System die Anzahl eines Spielzeugs in der Datenbank aktualisieren können.
Implementiere die Funktion updateQuantity(_:toy:Amount:), die folgende Argumente entgegennimmt:
-
toys, das ein Array von Tupeln vom Typ (name: String, quantity: Int) enthält.
-
toy, das den Namen des zu aktualisierenden Spielzeugs enthält.
-
amount, das die neue Anzahl des Spielzeugs enthält.
Du kannst davon ausgehen, dass das Spielzeug bereits in der Datenbank ist, und musst das nicht prüfen.
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. Füge einem Spielzeug einen Kategorieschlüssel hinzu
Der Weihnachtsmann möchte die Spielzeuge in der Datenbank kategorisieren können.
So kann er die Spielzeuge leicht finden, wenn er eine Lieferung machen muss, und die Spielzeuge in der Datenbank sortieren.
Allerdings wurde der Kategorieschlüssel vergessen, als das System zum ersten Mal implementiert wurde.
Jetzt muss das System einem Spielzeug in der Datenbank einen Kategorieschlüssel hinzufügen können.
Implementiere die Funktion addCategory(_:category:), die folgende Argumente entgegennimmt:
-
toys, das ein Array von Tupeln vom Typ (name: String, quantity: Int) enthält.
-
category, das den Kategorieschlüssel enthält, der zu den Spielzeugen hinzugefügt wird.
Du kannst davon ausgehen, dass das Spielzeug bereits in der Datenbank ist, und musst das nicht prüfen.
Du kannst außerdem davon ausgehen, dass das Spielzeug noch keinen Kategorieschlüssel hat.
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")]
Lernübung
