Swift Language
Commutateur

Paramètres

Remarques

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

Les instructions switch fonctionnent également avec des types de données autres que des entiers. Ils fonctionnent avec n'importe quel type de données. Voici un exemple d'activation d'une chaîne:

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

Cela imprimera les éléments suivants:

Animal is a house pet.

Faire correspondre plusieurs valeurs

Un seul cas dans une instruction switch peut correspondre à plusieurs valeurs.

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

Faire correspondre une plage

Un seul cas dans une instruction switch peut correspondre à une plage de valeurs.

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

Utilisation de l'instruction where dans un commutateur

L'instruction where peut être utilisée dans une correspondance de casse de commutateur pour ajouter des critères supplémentaires requis pour une correspondance positive. L'exemple suivant vérifie non seulement la plage, mais aussi si le nombre est impair ou pair:

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

Satisfaire l'une des contraintes multiples en utilisant switch

Vous pouvez créer un tuple et utiliser un commutateur comme ceci:

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

Correspondance partielle

L'instruction switch utilise une correspondance partielle.

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. Correspond exactement au cas où la valeur est (0,0,0). C'est l'origine de l'espace 3D.
2. Correspond à y = 0, z = 0 et toute valeur de x. Cela signifie que la coordonnée est sur l'axe des x.
3. Correspond à x = 0, z = 0 et à toute valeur de y. Cela signifie que la coordonnée est sur leur axe.
4. Correspond à x = 0, y = 0 et à toute valeur de z. Cela signifie que la coordonnée est sur l'axe des z.
5. Correspond au reste des coordonnées.

Remarque: l'utilisation du trait de soulignement signifie que vous ne vous souciez pas de la valeur.

Si vous ne voulez pas ignorer la valeur, vous pouvez l'utiliser dans votre instruction switch, comme ceci:

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

Ici, les cas des axes utilisent la syntaxe let pour extraire les valeurs pertinentes. Le code imprime ensuite les valeurs en utilisant une interpolation de chaîne pour générer la chaîne.

Remarque: vous n'avez pas besoin d'un paramètre par défaut dans cette instruction de commutateur. C'est parce que le cas final est essentiellement le défaut - il correspond à tout, car il n'y a aucune contrainte sur une partie quelconque du tuple. Si l'instruction switch change toutes les valeurs possibles avec ses cases, aucune valeur par défaut n'est nécessaire.

Nous pouvons également utiliser la syntaxe let-where pour rechercher des cas plus complexes. Par exemple:

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
}

Ici, nous faisons correspondre les lignes "y est égal à x" et "y est égal à x carré".

Changement de vitesse

Il est intéressant de noter que, rapidement, contrairement à d'autres langages, les gens sont familiers, il y a une rupture implicite à la fin de chaque déclaration de cas. Afin de suivre le cas suivant (c.-à- fallthrough . fallthrough plusieurs cas fallthrough ), vous devez utiliser fallthrough déclaration de fallthrough .

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

Ceci est utile pour des choses comme les flux.

Switch et Enums

L'instruction Switch fonctionne très bien avec les valeurs 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")
}

Comme nous avons fourni un cas pour chaque valeur possible de voiture, nous omettons le cas default .

Commutateur et options

Quelques exemples de cas où le résultat est facultatif.

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

Commutateurs et tuples

Les commutateurs peuvent activer les tuples:

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

Correspondance basée sur la classe - idéal pour prepareForSegue

Vous pouvez également faire un changement d’instruction de commutateur en fonction de la classe de la chose que vous allumez.

Un exemple où cela est utile est dans prepareForSegue . J'avais l'habitude de basculer en fonction de l'identifiant de segue, mais c'est fragile. Si vous modifiez votre storyboard ultérieurement et renommez l'identifiant de segue, il casse votre code. Ou, si vous utilisez segues pour plusieurs instances de la même classe de contrôleur de vue (mais pour différentes scènes de storyboard), vous ne pouvez pas utiliser l'identificateur de segue pour déterminer la classe de la destination.

Swift switch déclarations à la rescousse.

Utilisez la case let var as Class Swift case let var as Class syntaxe case let var as Class , comme ceci:

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