Swift Language
Schakelaar

parameters

Opmerkingen

Basisgebruik

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

schakelinstructies werken ook met andere gegevenstypen dan gehele getallen. Ze werken met elk gegevenstype. Hier is een voorbeeld van het inschakelen van een string:

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

Hiermee wordt het volgende afgedrukt:

Animal is a house pet.

Overeenkomen met meerdere waarden

Een enkel geval in een schakelinstructie kan overeenkomen met meerdere waarden.

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

Overeenkomen met een bereik

Een enkel geval in een schakelinstructie kan overeenkomen met een bereik van waarden.

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

Gebruik de Where-instructie in een schakelaar

De Where-instructie kan worden gebruikt binnen een schakelgevalovereenkomst om aanvullende criteria toe te voegen die vereist zijn voor een positieve overeenkomst. Het volgende voorbeeld controleert niet alleen het bereik, maar ook of het nummer even of oneven is:

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

Voldoen aan een van meerdere beperkingen met behulp van schakelaar

Je kunt een tuple maken en een schakelaar als volgt gebruiken:

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

Gedeeltelijke matching

Schakel statement maken gebruik van gedeeltelijke matching.

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. Komt precies overeen met het geval waarin de waarde (0,0,0) is. Dit is de oorsprong van 3D-ruimte.
2. Komt overeen met y = 0, z = 0 en elke waarde van x. Dit betekent dat de coördinaat zich op de x-as bevindt.
3. Komt overeen met x = 0, z = 0 en elke waarde van y. Dit betekent dat de coördinaat op hun as ligt.
4. Komt overeen met x = 0, y = 0 en elke waarde van z. Dit betekent dat de coördinaat zich op de z-as bevindt.
5. Komt overeen met de rest van de coördinaten.

Opmerking: als u het onderstrepingsteken gebruikt, betekent dit dat u niet om de waarde geeft.

Als u de waarde niet wilt negeren, kunt u deze als volgt in uw schakelopdracht gebruiken:

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 gebruiken de asgevallen de let-syntaxis om de relevante waarden eruit te halen. De code drukt vervolgens de waarden af met stringinterpolatie om de string op te bouwen.

Opmerking: u hebt geen standaard nodig in deze schakeloptie. Dit komt omdat het laatste geval in wezen de standaard is - het komt overeen met alles, omdat er geen beperkingen zijn aan enig deel van de tuple. Als de schakeloptie alle mogelijke waarden met zijn gevallen opgebruikt, is geen standaardwaarde vereist.

We kunnen ook de let-where-syntaxis gebruiken om meer complexe gevallen te matchen. Bijvoorbeeld:

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 komen we overeen met de lijnen "y is x" en "y is x x squared".

Schakel doorvallen

Het is vermeldenswaard dat er, in tegenstelling tot andere talen waarmee mensen bekend zijn, een impliciete breuk aan het einde van elke case-statement is. Om door te gaan naar de volgende casus (dat wil zeggen dat meerdere casussen worden uitgevoerd) moet u de fallthrough instructie gebruiken.

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

dit is handig voor dingen zoals streams.

Schakelen en Enums

De instructie Switch werkt erg goed met Enum-waarden

enum CarModel {
    case Standard, Fast, VeryFast
}

let car = CarModel.Standard

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

Omdat we voor elke mogelijke waarde van de auto een case hebben opgegeven, laten we de default .

Schakelaar en opties

Enkele voorbeeldgevallen waarbij het resultaat optioneel is.

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

Schakelaars en tupels

Schakelaars kunnen tupels inschakelen:

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

Overeenkomen op basis van klasse - ideaal voor prepareForSegue

Je kunt ook een switch-statement switch maken op basis van de klasse van het ding dat je aanzet.

Een voorbeeld waar dit handig is, is in prepareForSegue . Ik gebruikte om te schakelen op basis van de segue-id, maar dat is kwetsbaar. als u uw storyboard later wijzigt en de naam van de segue-id wijzigt, wordt uw code verbroken. Of, als u segmenten gebruikt voor meerdere instanties dezelfde viewcontrollerklasse (maar verschillende storyboardscènes), dan kunt u de segue-ID niet gebruiken om de klasse van de bestemming te achterhalen.

Swift schakel verklaringen te hulp.

Gebruik Swift- case let var as Class syntaxis, zoals hier:

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