Zoeken…


Invoering

Een tuple-type is een door komma's gescheiden lijst met typen, tussen haakjes.

Deze lijst met typen kan ook de naam van de elementen hebben en die namen gebruiken om te verwijzen naar de waarden van de afzonderlijke elementen.

Een elementnaam bestaat uit een ID, onmiddellijk gevolgd door een dubbele punt (:).

Normaal gebruik -

We kunnen een tuple-type gebruiken als het retourtype van een functie om de functie in staat te stellen een enkele tuple met meerdere waarden te retourneren

Opmerkingen

Tuples worden als waardetypes beschouwd. Meer informatie over tupels is te vinden in de documentatie: developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html

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
    }


Modified text is an extract of the original Stack Overflow Documentation
Licentie onder CC BY-SA 3.0
Niet aangesloten bij Stack Overflow