Swift Language
Tuples

Introduction

Remarques

Que sont les tuples?

Les tuples regroupent plusieurs valeurs en une seule valeur composée. Les valeurs dans un tuple peuvent être de tout type et ne doivent pas nécessairement être du même type.

Les tuples sont créés en regroupant toute quantité de valeurs:

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

Des valeurs individuelles peuvent également être nommées lors de la définition du tuple:

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

Ils peuvent également être nommés lorsqu'ils sont utilisés en tant que variable et peuvent même avoir des valeurs facultatives à l'intérieur:

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

Se décomposer en variables individuelles

Les tuples peuvent être décomposés en variables individuelles avec la syntaxe suivante:

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

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

Cette syntaxe peut être utilisée indépendamment du fait que le tuple ait des propriétés non nommées:

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

Les propriétés spécifiques peuvent être ignorées en utilisant le trait de soulignement ( _ ):

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

Tuples comme valeur de retour des fonctions

Les fonctions peuvent renvoyer des tuples:

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

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

Si vous attribuez des noms de paramètres, ils peuvent être utilisés à partir de la valeur de retour:

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

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

Utiliser un typealias pour nommer votre type de tuple

Parfois, vous pouvez utiliser le même type de tuple à plusieurs endroits dans votre code. Cela peut rapidement devenir compliqué, surtout si votre tuple est complexe:

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

Si vous utilisez un certain type de tuple à plusieurs endroits, vous pouvez utiliser le mot-clé typealias pour nommer votre type de tuple.

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

Si vous le faites trop souvent, vous devriez plutôt envisager d'utiliser une struct .

Echange de valeurs

Les tuples sont utiles pour échanger des valeurs entre 2 (ou plus) variables sans utiliser de variables temporaires.

Exemple avec 2 variables

Compte tenu de 2 variables

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

nous pouvons facilement échanger les valeurs

(a, b) = (b, a)

Résultat:

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

Exemple avec 4 variables

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 comme cas dans Switch

Utiliser des tuples dans un commutateur

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
}

Ou en combinaison avec un Enum Par exemple avec Size Classes:

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