Swift Language
Schalter

Parameter

Bemerkungen

Grundlegende Verwendung

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

switch-Anweisungen funktionieren auch mit anderen Datentypen als Ganzzahlen. Sie arbeiten mit jedem Datentyp. Hier ist ein Beispiel für das Aktivieren einer Zeichenfolge

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

Dadurch wird Folgendes gedruckt:

Animal is a house pet.

Mehrere Werte abgleichen

Ein einzelner Fall in einer switch-Anweisung kann mit mehreren Werten übereinstimmen.

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

Einen Bereich abgleichen

Ein einzelner Fall in einer switch-Anweisung kann einem Wertebereich entsprechen.

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

Verwenden der where-Anweisung in einem Schalter

Die where-Anweisung kann innerhalb einer Übereinstimmungsfall-Übereinstimmung verwendet werden, um zusätzliche Kriterien hinzuzufügen, die für eine positive Übereinstimmung erforderlich sind. Das folgende Beispiel prüft nicht nur den Bereich, sondern auch, ob die Anzahl gerade oder ungerade ist:

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

Erfüllen Sie eine von mehreren Einschränkungen mit switch

Sie können ein Tupel erstellen und einen Schalter wie folgt verwenden:

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

Teilweise Übereinstimmung

Die switch-Anweisung verwendet eine partielle Übereinstimmung.

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. Stimmt genau mit dem Fall überein, in dem der Wert (0,0,0) ist. Dies ist der Ursprung des 3D-Raums.
2. Stimmt mit y = 0, z = 0 und einem beliebigen Wert von x überein. Dies bedeutet, dass sich die Koordinate auf der x-Achse befindet.
3. Stimmt mit x = 0, z = 0 und einem beliebigen Wert von y überein. Dies bedeutet, dass sich die Koordinate auf ihrer Achse befindet.
4. Stimmt mit x = 0, y = 0 und einem beliebigen Wert von z überein. Dies bedeutet, dass sich die Koordinate auf der Z-Achse befindet.
5. Stimmt mit den restlichen Koordinaten überein.

Hinweis: Wenn Sie den Unterstrich verwenden, bedeutet das, dass Sie sich nicht für den Wert interessieren.

Wenn Sie den Wert nicht ignorieren möchten, können Sie ihn wie folgt in Ihrer switch-Anweisung verwenden:

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

Hier verwenden die Achsenfälle die Let-Syntax, um die relevanten Werte herauszuholen. Der Code druckt dann die Werte mithilfe der Zeichenfolgeninterpolation aus, um die Zeichenfolge zu erstellen.

Hinweis: In dieser switch-Anweisung benötigen Sie keinen Standard. Dies liegt daran, dass der letzte Fall im Wesentlichen die Standardeinstellung ist - er stimmt mit allem überein, da es keinerlei Einschränkungen für das Tupel gibt. Wenn die switch-Anweisung alle möglichen Werte mit ihren Fällen erschöpft, ist kein Standardwert erforderlich.

Wir können auch die let-where-Syntax verwenden, um komplexere Fälle abzugleichen. Zum Beispiel:

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
}

Hier stimmen wir mit den Zeilen "y gleich x" und "y gleich x Quadrat" überein.

Fallthroughs wechseln

Es ist erwähnenswert, dass im Gegensatz zu anderen Sprachen, die den Leuten bekannt sind, am Ende jeder Fallaussage ein impliziter Bruch vorliegt. Um den nächsten Fall fallthrough (dh mehrere Fälle ausführen zu lassen), müssen Sie die fallthrough Anweisung verwenden.

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

Dies ist nützlich für Dinge wie Streams.

Switch und Enums

Die Switch-Anweisung funktioniert sehr gut mit Enum-Werten

enum CarModel {
    case Standard, Fast, VeryFast
}

let car = CarModel.Standard

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

Da wir für jeden möglichen Wert des Autos einen Fall angegeben haben, wird der default weggelassen.

Schalter und Optionals

Einige Beispiele, in denen das Ergebnis optional ist.

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

Schalter und Tupel

Schalter können Tupel einschalten:

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

Matching basierend auf dem Unterricht - ideal für prepareForSegue

Sie können eine switch-Anweisung auch basierend auf der Klasse der Sache, die Sie einschalten, wechseln.

Ein Beispiel, in dem dies nützlich ist, ist in prepareForSegue . Früher habe ich auf der Grundlage der Segmentkennung gewechselt, aber das ist fragil. Wenn Sie Ihr Storyboard später ändern und die Segmentkennung umbenennen, wird der Code beschädigt. Wenn Sie Segmente für mehrere Instanzen derselben View-Controller-Klasse (aber unterschiedliche Storyboard-Szenen) verwenden, können Sie die Segment-ID nicht verwenden, um die Klasse des Ziels herauszufinden.

Schnelle Wechselaussagen zur Rettung.

Verwenden Sie Swift case let var as Class wie folgt:

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