Swift Language
Växla

parametrar

Anmärkningar

Grundläggande användning

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-uttalanden fungerar också med andra datatyper än heltal. De arbetar med vilken datatyp som helst. Här är ett exempel på att slå på en sträng:

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

Detta kommer att skriva ut följande:

Animal is a house pet.

Matcha flera värden

Ett enda fall i en switch-uttalande kan matcha flera värden.

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

Matchar ett intervall

Ett enda fall i en switch-uttalande kan matcha ett antal värden.

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

Använd var-uttalandet i en switch

Uttalningen där kan användas i en switch-matchmatch för att lägga till ytterligare kriterier som krävs för en positiv matchning. Följande exempel kontrollerar inte bara intervallet utan också om antalet är udda eller jämnt:

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

Tillfredsställa en av flera begränsningar med omkopplare

Du kan skapa en tupel och använda en switch på så sätt:

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

Partiell matchning

Byt uttalande använder delvis matchning.

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. Matchar exakt det fall där värdet är (0,0,0). Detta är ursprunget till 3D-rymden.
2. Matchar y = 0, z = 0 och valfritt värde på x. Detta betyder att koordinaten är på x-axeln.
3. Matchar x = 0, z = 0 och valfritt värde på y. Detta betyder att koordinaten är på deras axel.
4. Matchar x = 0, y = 0 och valfritt värde på z. Detta betyder att koordinaten är på z-axeln.
5. Matchar resten av koordinaterna.

Obs! Använd understreck för att betyda att du inte bryr dig om värdet.

Om du inte vill ignorera värdet kan du använda det i ditt switch-uttalande, så här:

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

Här använder axelfallen låtsyntaxen för att dra ut de relevanta värdena. Koden skriver sedan ut värdena med stränginterpolering för att bygga strängen.

Obs! Du behöver inte ha ett standardvärde i det här kopplingsmeddelandet. Detta beror på att det slutliga fallet i huvudsak är standardvärdet - det matchar vad som helst, eftersom det inte finns några begränsningar för någon del av tupeln. Om switch-uttalandet tappar ut alla möjliga värden med dess fall, är ingen standard nödvändig.

Vi kan också använda låt-där-syntaxen för att matcha mer komplexa fall. Till exempel:

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
}

Här matchar vi linjerna "y är lika med x" och "y är lika med x i kvadrat".

Växla genombrott

Det är värt att notera att det på ett snabbt sätt, till skillnad från andra språk som folk känner till, finns en implicit brytning i slutet av varje ärende. För att följa till nästa fall (dvs att flera fall körs) måste du använda ett fallthrough uttalande.

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

detta är användbart för saker som strömmar.

Byt och Enums

Switch-uttalandet fungerar mycket bra med Enum-värden

enum CarModel {
    case Standard, Fast, VeryFast
}

let car = CarModel.Standard

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

Eftersom vi lämnade ett ärende för varje möjligt bilvärde, utelämnar vi default .

Brytare och tillval

Några exempelfall när resultatet är valfritt.

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

Växlar och tupplar

Omkopplare kan slå på 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)"
}

Matchning baserat på klass - bra för förberedelseForSegue

Du kan också göra en switch-switch-switch baserad på klassen för det du sätter på.

Ett exempel där detta är användbart är i prepareForSegue . Jag brukade byta baserat på segue-identifieraren, men det är bräckligt. om du ändrar ditt storyboard senare och byter namn på segue-identifieraren, bryter det din kod. Eller om du använder segues till flera instanser av samma visningskontrollklass (men olika storyboard-scener) kan du inte använda segue-identifieraren för att räkna ut destinationens klass.

Snabb växla uttalanden till undsättning.

Använd Swift case let var as Class syntax, så här:

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