Swift Language
tuples

Invoering

Opmerkingen

Wat zijn Tuples?

Tuples groeperen meerdere waarden in één samengestelde waarde. De waarden binnen een tuple kunnen van elk type zijn en hoeven niet van hetzelfde type te zijn als elkaar.

Tupels worden gemaakt door een willekeurig aantal waarden te groeperen:

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

Ook kunnen individuele waarden worden benoemd wanneer de tuple is gedefinieerd:

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

Ze kunnen ook worden genoemd als ze als variabele worden gebruikt en hebben zelfs de mogelijkheid om optionele waarden binnen te hebben:

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

Ontleden in afzonderlijke variabelen

Tupels kunnen worden opgesplitst in afzonderlijke variabelen met de volgende syntaxis:

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

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

Deze syntaxis kan worden gebruikt ongeacht of de tuple onbenoemde eigenschappen heeft:

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

Specifieke eigenschappen kunnen worden genegeerd met behulp van underscore ( _ ):

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

Tuples als de retourwaarde van functies

Functies kunnen tupels teruggeven:

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

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

Als u parameternamen toewijst, kunnen deze worden gebruikt vanaf de retourwaarde:

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

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

Typalias gebruiken om uw tuple-type een naam te geven

Soms wil je hetzelfde tuple-type op meerdere plaatsen in je code gebruiken. Dit kan snel rommelig worden, vooral als je tuple complex is:

// 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)
}

Als u een bepaald tuple-type op meerdere plaatsen gebruikt, kunt u het sleutelwoord typealias om uw tuple-type een naam te geven.

// 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)
}

Als je merkt dat je dit te vaak doet, moet je in plaats daarvan overwegen een struct gebruiken.

Waarden omwisselen

Tuples zijn handig om waarden tussen 2 (of meer) variabelen te wisselen zonder tijdelijke variabelen te gebruiken.

Voorbeeld met 2 variabelen

Gegeven 2 variabelen

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

we kunnen de waarden gemakkelijk omwisselen

(a, b) = (b, a)

Resultaat:

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

Voorbeeld met 4 variabelen

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

Gebruik tupels in een schakelaar

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
}

Of in combinatie met een Enum bijvoorbeeld met grootteklassen:

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