Swift Language
Le tuple

introduzione

Osservazioni

Cosa sono le tuple?

Le tuple raggruppano più valori in un singolo valore composto. I valori all'interno di una tupla possono essere di qualsiasi tipo e non devono essere dello stesso tipo l'uno dell'altro.

Le tuple vengono create raggruppando qualsiasi quantità di valori:

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

Anche i singoli valori possono essere nominati quando viene definita la tupla:

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

Possono anche essere nominati quando vengono utilizzati come variabili e persino avere la possibilità di avere valori opzionali all'interno:

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

Scomponendosi in singole variabili

Le tuple possono essere scomposte in singole variabili con la seguente sintassi:

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

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

Questa sintassi può essere utilizzata indipendentemente dal fatto che la tupla abbia proprietà senza nome:

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

Le proprietà specifiche possono essere ignorate utilizzando il carattere di sottolineatura ( _ ):

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

Tuple come valore di ritorno delle funzioni

Le funzioni possono restituire tuple:

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

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

Se assegni i nomi dei parametri, possono essere utilizzati dal valore restituito:

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

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

Usando un typealias per nominare il tuo tipo di tupla

Occasionalmente potresti voler usare lo stesso tipo di tupla in più punti del codice. Questo può diventare rapidamente disordinato, specialmente se la tua tupla è complessa:

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

Se si utilizza un determinato tipo di tupla in più di una posizione, è possibile utilizzare la parola chiave typealias per denominare il tipo di tupla.

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

Se ti accorgi di farlo troppo spesso, dovresti prendere in considerazione l'utilizzo di una struct .

Scambiare valori

Le tuple sono utili per scambiare valori tra 2 (o più) variabili senza utilizzare variabili temporanee.

Esempio con 2 variabili

Dato 2 variabili

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

possiamo facilmente scambiare i valori

(a, b) = (b, a)

Risultato:

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

Esempio con 4 variabili

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

Tuple come Case in Switch

Usa le tuple in un interruttore

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
}

O in combinazione con un Enum Ad esempio con Classi di Dimensione:

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