Swift Language
Tuples

Einführung

Bemerkungen

Was sind Tupel?

Tupel gruppieren mehrere Werte in einen einzigen zusammengesetzten Wert. Die Werte innerhalb eines Tupels können von einem beliebigen Typ sein und müssen nicht vom selben Typ sein.

Tupel werden durch Gruppieren einer beliebigen Anzahl von Werten erstellt:

let tuple = ("one", 2, "three")

// Values are read using index numbers starting at zero
print(tuple.0) // one
print(tuple.1) // 2
print(tuple.2) // three

Bei der Definition des Tupels können auch einzelne Werte benannt werden:

let namedTuple = (first: 1, middle: "dos", last: 3)

// Values can be read with the named property
print(namedTuple.first)  // 1
print(namedTuple.middle) // dos

// And still with the index number
print(namedTuple.2)      // 3

Sie können auch benannt werden, wenn sie als Variable verwendet werden. Sie können sogar optionale Werte enthalten:

var numbers: (optionalFirst: Int?, middle: String, last: Int)?

//Later On
numbers = (nil, "dos", 3)

print(numbers.optionalFirst)// nil
print(numbers.middle)//"dos"
print(numbers.last)//3

In einzelne Variablen zerlegen

Tupel können mit folgender Syntax in einzelne Variablen zerlegt werden:

let myTuple = (name: "Some Name", age: 26)
let (first, second) = myTuple

print(first) // "Some Name"
print(second)  // 26

Diese Syntax kann unabhängig davon verwendet werden, ob das Tupel über unbenannte Eigenschaften verfügt:

let unnamedTuple = ("uno", "dos")
let (one, two) = unnamedTuple
print(one) // "uno"
print(two) // "dos"

Bestimmte Eigenschaften können mit Unterstrich ( _ ) ignoriert werden:

let longTuple = ("ichi", "ni", "san")
let (_, _, third) = longTuple
print(third) // "san"

Tupel als Rückgabewert von Funktionen

Funktionen können Tupel zurückgeben:

func tupleReturner() -> (Int, String) {
    return (3, "Hello")
}

let myTuple = tupleReturner()
print(myTuple.0) // 3
print(myTuple.1) // "Hello"

Wenn Sie Parameternamen vergeben, können diese vom Rückgabewert verwendet werden:

func tupleReturner() -> (anInteger: Int, aString: String) {
    return (3, "Hello")
}

let myTuple = tupleReturner()
print(myTuple.anInteger) // 3
print(myTuple.aString) // "Hello"

Verwenden Sie einen Typealias, um Ihren Tupeltyp zu benennen

Gelegentlich möchten Sie möglicherweise denselben Tupeltyp an mehreren Stellen in Ihrem Code verwenden. Dies kann schnell unübersichtlich werden, insbesondere wenn Ihr Tupel komplex ist:

// Define a circle tuple by its center point and radius
let unitCircle: (center: (x: CGFloat, y: CGFloat), radius: CGFloat) = ((0.0, 0.0), 1.0)

func doubleRadius(ofCircle circle: (center: (x: CGFloat, y: CGFloat), radius: CGFloat)) -> (center: (x: CGFloat, y: CGFloat), radius: CGFloat) {
    return (circle.center, circle.radius * 2.0)
}

Wenn Sie einen bestimmten Tupel-Typ an mehreren typealias , können Sie das Schlüsselwort typealias , um Ihren Tupel-Typ zu benennen.

// Define a circle tuple by its center point and radius
typealias Circle = (center: (x: CGFloat, y: CGFloat), radius: CGFloat)

let unitCircle: Circle = ((0.0, 0.0), 1)

func doubleRadius(ofCircle circle: Circle) -> Circle {
    // Aliased tuples also have access to value labels in the original tuple type.
    return (circle.center, circle.radius * 2.0)
}

Wenn Sie dies jedoch zu oft tun, sollten Sie stattdessen eine struct verwenden.

Werte austauschen

Tupel sind nützlich, um Werte zwischen 2 (oder mehr) Variablen auszutauschen, ohne temporäre Variablen zu verwenden.

Beispiel mit 2 Variablen

Gegeben 2 Variablen

var a = "Marty McFly"
var b = "Emmett Brown"

wir können die Werte leicht austauschen

(a, b) = (b, a)

Ergebnis:

print(a) // "Emmett Brown" 
print(b) // "Marty McFly"

Beispiel mit 4 Variablen

var a = 0
var b = 1
var c = 2
var d = 3

(a, b, c, d) = (d, c, b, a)

print(a, b, c, d) // 3, 2, 1, 0

Tuples als Case in Switch

Verwenden Sie Tupel in einem Switch

let switchTuple = (firstCase: true, secondCase: false)
   
switch switchTuple {   
 case (true, false):
    // do something
 case (true, true):
    // do something
 case (false, true):
    // do something
 case (false, false):
    // do something
}

Oder in Kombination mit einer Aufzählung. Zum Beispiel mit Größenklassen:

    let switchTuple = (UIUserInterfaceSizeClass.Compact, UIUserInterfaceSizeClass.Regular)
    
    switch switchTuple {
    case (.Regular, .Compact):
        //statement
    case (.Regular, .Regular):
        //statement
    case (.Compact, .Regular):
        //statement
    case (.Compact, .Compact):
        //statement
    }