Swift Language
Cambiar

Parámetros

Observaciones

Uso básico

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

Las instrucciones de conmutación también funcionan con tipos de datos que no sean enteros. Funcionan con cualquier tipo de datos. Aquí hay un ejemplo de cómo cambiar una cadena:

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

Esto imprimirá lo siguiente:

Animal is a house pet.

Coincidencia de valores múltiples

Un solo caso en una instrucción de conmutación puede coincidir en varios valores.

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

Haciendo juego un rango

Un solo caso en una instrucción de cambio puede coincidir con un rango de valores.

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

Usando la instrucción where en un switch

La declaración donde se puede usar dentro de una coincidencia de caso de conmutador para agregar criterios adicionales requeridos para una coincidencia positiva. El siguiente ejemplo comprueba no solo el rango, sino también si el número es impar o par:

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

Satisfacer una de las múltiples restricciones usando el interruptor

Puedes crear una tupla y usar un interruptor como tal:

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

Emparejamiento parcial

Cambiar la instrucción hace uso de la coincidencia parcial.

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. Coincide precisamente con el caso donde el valor es (0,0,0). Este es el origen del espacio 3D.
2. Coincide con y = 0, z = 0 y cualquier valor de x. Esto significa que la coordenada está en el eje x.
3. Coincide con x = 0, z = 0 y cualquier valor de y. Esto significa que la coordenada está en ellos- eje.
4. Coincide con x = 0, y = 0 y cualquier valor de z. Esto significa que la coordenada está en el eje z.
5. Coincide con el resto de coordenadas.

Nota: usar el guión bajo para significar que no te importa el valor.

Si no quiere ignorar el valor, entonces puede usarlo en su declaración de cambio, como esto:

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

Aquí, los casos de ejes utilizan la sintaxis de let para extraer los valores pertinentes. El código luego imprime los valores utilizando la interpolación de cadenas para construir la cadena.

Nota: no necesita un valor predeterminado en esta instrucción de cambio. Esto se debe a que el caso final es esencialmente el predeterminado: coincide con cualquier cosa, porque no hay restricciones en ninguna parte de la tupla. Si la instrucción de cambio agota todos los valores posibles con sus casos, entonces no es necesario un valor predeterminado.

También podemos usar la sintaxis de let-where para hacer coincidir casos más complejos. Por ejemplo:

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
}

Aquí, hacemos coincidir las líneas "y es igual a x" y "y es igual a x al cuadrado".

Cambiar fracasos

Vale la pena señalar que en Swift, a diferencia de otros idiomas con los que las personas están familiarizadas, hay una ruptura implícita al final de cada declaración de caso. Para poder continuar con el siguiente caso (es decir, tener varios casos ejecutados), debe usar fallthrough declaración fallthrough .

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

Esto es útil para cosas como arroyos.

Interruptor y Enums

La instrucción Switch funciona muy bien con los valores de 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")
}

Dado que proporcionamos un caso para cada valor posible de automóvil, omitimos el caso default .

Interruptor y Opcionales

Algunos casos de ejemplo cuando el resultado es opcional.

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

Interruptores y tuplas

Los interruptores pueden activar tuplas:

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

Coincidencia basada en clase - ideal para prepareForSegue

También puede hacer un cambio de instrucción basado en la clase de lo que está activando.

Un ejemplo donde esto es útil es en prepareForSegue . Solía ​​cambiar según el identificador de segue, pero eso es frágil. Si cambia su guión gráfico más tarde y cambia el nombre del identificador de segue, se rompe su código. O, si usa segues para múltiples instancias en la misma clase de controlador de vista (pero diferentes escenas del guión gráfico), entonces no puede usar el identificador de segue para averiguar la clase del destino.

Cambio rápido de las declaraciones al rescate.

Use Swift case let var as Class sintaxis de case let var as Class , como esto:

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