Swift Language
Interruttore

Parametri

Osservazioni

Uso di base

let number = 3
switch number {
case 1:
    print("One!")
case 2:
    print("Two!")
case 3:
    print("Three!")
default:
    print("Not One, Two or Three")
}

le istruzioni switch funzionano anche con tipi di dati diversi dagli interi. Funzionano con qualsiasi tipo di dati. Ecco un esempio di accensione di una stringa:

let string = "Dog"
switch string {
case "Cat", "Dog":
  print("Animal is a house pet.")
default:
  print("Animal is not a house pet.")
}

Questo stamperà il seguente:

Animal is a house pet.

Abbinamento di più valori

Un singolo caso in un'istruzione switch può corrispondere su più valori.

let number = 3
switch number {
case 1, 2:
    print("One or Two!")
case 3:
    print("Three!")
case 4, 5, 6:
    print("Four, Five or Six!")
default:
    print("Not One, Two, Three, Four, Five or Six")
}

Abbinare una gamma

Un singolo caso in un'istruzione switch può corrispondere a un intervallo di valori.

let number = 20
switch number {
case 0:
    print("Zero")
case 1..<10:
    print("Between One and Ten")
case 10..<20:
    print("Between Ten and Twenty")
case 20..<30:
    print("Between Twenty and Thirty")
default:
    print("Greater than Thirty or less than Zero")
}

Utilizzando l'istruzione where in un interruttore

L'istruzione where può essere utilizzata all'interno di una corrispondenza caso switch per aggiungere ulteriori criteri richiesti per una corrispondenza positiva. L'esempio seguente controlla non solo l'intervallo, ma anche se il numero è pari o dispari:

switch (temperature) {
      case 0...49 where temperature % 2 == 0:
        print("Cold and even")

      case 50...79 where temperature % 2 == 0:
        print("Warm and even")

      case 80...110 where temperature % 2 == 0:
        print("Hot and even")

      default:
        print("Temperature out of range or odd")
}

Soddisfare uno dei molteplici vincoli utilizzando l'interruttore

Puoi creare una tupla e usare un interruttore in questo modo:

var str: String? = "hi"
var x: Int? = 5

switch (str, x) {
case (.Some,.Some):
    print("Both have values")
case (.Some, nil):
    print("String has a value")
case (nil, .Some):
    print("Int has a value")
case (nil, nil):
    print("Neither have values")
}

Corrispondenza parziale

L'istruzione switch utilizza l'abbinamento parziale.

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)

switch (coordinates) {
case (0, 0, 0): // 1
  print("Origin")
case (_, 0, 0): // 2
  print("On the x-axis.")
case (0, _, 0): // 3
  print("On the y-axis.")
case (0, 0, _): // 4
  print("On the z-axis.")
default:        // 5
  print("Somewhere in space")
}

1. Corrisponde esattamente al caso in cui il valore è (0,0,0). Questa è l'origine dello spazio 3D.
2. Corrisponde a y = 0, z = 0 e qualsiasi valore di x. Ciò significa che la coordinata è sull'asse x.
3. Corrisponde a x = 0, z = 0 e qualsiasi valore di y. Ciò significa che la coordinata si trova sull'asse dell'asse.
4. Corrisponde a x = 0, y = 0 e qualsiasi valore di z. Ciò significa che la coordinata è sull'asse z.
5. Corrisponde al resto delle coordinate.

Nota: usare il carattere di sottolineatura per indicare che non ti interessa il valore.

Se non vuoi ignorare il valore, puoi utilizzarlo nella tua istruzione switch, in questo modo:

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)

switch (coordinates) {
case (0, 0, 0):
  print("Origin")
case (let x, 0, 0):
  print("On the x-axis at x = \(x)")
case (0, let y, 0):
  print("On the y-axis at y = \(y)")
case (0, 0, let z):
  print("On the z-axis at z = \(z)")
case (let x, let y, let z):
  print("Somewhere in space at x = \(x), y = \(y), z = \(z)")
}

Qui, i casi degli assi usano la sintassi let per estrarre i valori pertinenti. Il codice quindi stampa i valori utilizzando l'interpolazione della stringa per creare la stringa.

Nota: non è necessario un valore predefinito in questa istruzione switch. Questo perché il caso finale è essenzialmente quello di default: corrisponde a qualsiasi cosa, perché non ci sono vincoli su nessuna parte della tupla. Se l'istruzione switch esaurisce tutti i valori possibili con i relativi casi, non è necessario alcun valore predefinito.

Possiamo anche usare la sintassi let-where per abbinare casi più complessi. Per esempio:

let coordinates: (x: Int, y: Int, z: Int) = (3, 2, 5)

switch (coordinates) {
case (let x, let y, _) where y == x:
  print("Along the y = x line.")
case (let x, let y, _) where y == x * x:
  print("Along the y = x^2 line.")
default:
break
}

Qui, corrispondiamo alle linee "y equals x" e "y equals x squared".

Scorri le innovazioni

Vale la pena notare che in modo rapido, a differenza di altre lingue con cui le persone hanno familiarità, c'è una interruzione implicita alla fine di ogni dichiarazione di un caso. Per seguire il caso successivo (es. fallthrough più casi) è necessario utilizzare la dichiarazione fallthrough .

switch(value) {
case 'one':
    // do operation one
    fallthrough
case 'two':
    // do this either independant, or in conjunction with first case
default:
    // default operation
}

questo è utile per cose come i flussi.

Cambia ed Enum

L'istruzione Switch funziona molto bene con i valori Enum

enum CarModel {
    case Standard, Fast, VeryFast
}

let car = CarModel.Standard

switch car {
case .Standard: print("Standard")
case .Fast: print("Fast")
case .VeryFast: print("VeryFast")
}

Poiché abbiamo fornito un caso per ogni possibile valore della macchina, omettiamo il caso default .

Switch e Optionals

Alcuni esempi di casi in cui il risultato è facoltativo.

var result: AnyObject? = someMethod()

switch result {
case nil:
    print("result is nothing")
case is String:
    print("result is a String")
case _ as Double:
    print("result is not nil, any value that is a Double")
case let myInt as Int where myInt > 0:
    print("\(myInt) value is not nil but an int and greater than 0")
case let a?:
    print("\(a) - value is unwrapped")
}

Interruttori e tuple

Gli interruttori possono accendere le tuple:

public typealias mdyTuple = (month: Int, day: Int, year: Int)

let fredsBirthday =   (month: 4, day: 3, year: 1973)




switch theMDY
{
//You can match on a literal tuple:
case (fredsBirthday):
  message = "\(date) \(prefix) the day Fred was born"

//You can match on some of the terms, and ignore others:
case (3, 15, _):
  message = "Beware the Ides of March"

//You can match on parts of a literal tuple, and copy other elements
//into a constant that you use in the body of the case:
case (bobsBirthday.month, bobsBirthday.day, let year) where year > bobsBirthday.year:
  message = "\(date) \(prefix) Bob's \(possessiveNumber(year - bobsBirthday.year))" +
    "birthday"

//You can copy one or more elements of the tuple into a constant and then
//add a where clause that further qualifies the case:
case (susansBirthday.month, susansBirthday.day, let year) 
  where year > susansBirthday.year:
  message = "\(date) \(prefix) Susan's " +
    "\(possessiveNumber(year - susansBirthday.year)) birthday"

//You can match some elements to ranges:.
case (5, 1...15, let year):
  message = "\(date) \(prefix) in the first half of May, \(year)"
}

Abbinamento basato sulla classe - ottimo per preparare ForSegue

Puoi anche fare un cambio di istruzione switch in base alla classe della cosa che stai accendendo.

Un esempio in cui questo è utile è in prepareForSegue . Ho usato passare in base all'identificatore di seguito, ma è fragile. se cambi lo storyboard in un secondo momento e rinomina l'identificatore dei passaggi, il tuo codice verrà violato. Oppure, se si utilizza segues per più istanze della stessa classe di controller di visualizzazione (ma scene di storyboard diverse), non è possibile utilizzare l'identificatore di follow per calcolare la classe della destinazione.

Dichiarazioni di commutazione rapida in soccorso.

Usa case let var as Class Swift e case let var as Class sintassi di case let var as Class , come questo:

override func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
  switch segue.destinationViewController {
    case let fooViewController as FooViewController:
      fooViewController.delegate = self

    case let barViewController as BarViewController:
      barViewController.data = data

    default:
      break
  }
}

override func prepare(for segue: UIStoryboardSegue, sender: AnyObject?) {       
  switch segue.destinationViewController {
    case let fooViewController as FooViewController:
      fooViewController.delegate = self

    case let barViewController as BarViewController:
      barViewController.data = data

    default:
      break
  }
}