Swift Switch or, the Fun Conditions Are

The most used example

Here I will show you a piece of code, which I will describe in the next section.

let string = "Hello, playground" //1
  let value = false
  var endString: String //2

  switch string {
  case "Hello, playground" where value: //3
      endString = "case one with value"
  case "a", "b", "c": //4
      endString = "case with 3 values"
  case "Goodbye playgrand": //5
      endString = "Goodbye"
  case _ where !value: //6
      endString = "Yo!"
  default: //7
      endString = "default"
  }

1. I create a string constant.
2. The variable string, which we will overwrite in the switch.
3. The value of the string is correct, but I added “where”, which also checks the value specified further.
4. You can give several values after a comma, and if either is correct, the switch enters into given case.
5. The value given is not correct, the case will also be omitted.
6. Instead of specifying value you can give a lower dash, which means that regardless of this value, we should enter the case.
7. The word “default” means that the case will be entered only if all other values ​​do not match.

Optionals

let text = "Text" as AnyObject? //1
switch text {
case let text? where text is Int: //2
print(text as! Int)
case let text? where text is String: //3
print(text as! String)
default: ()
}

1. Another variable with a string value, but declared as an optional subject of Any.
2. Check if the text is nil and then, with “where”, check whether the object is an int.
3. Check if the text is nil and then, with “where”, check whether the object is a string.

Ints

let a = 1
let b = 2
var c = 0

switch (a, b) { //1
case (1, 2), (2, 3): //2
c = 12
fallthrough //3

case (2,_): //4
c += 1
case (let aValue, 2): //5
print("a = \(aValue)")
case (let eitherValue, 2), (2, let eitherValue): //6
print("either value: \(eitherValue)")
case (0...3, 0...100): //7
c += 5
fallthrough
default:
c = 17
}

1. In case of such code, the switch will check both constants.
2. This way, you can handle several cases at once, using only one condition.
3. The word “fallthrough” means a transition to the next condition, so if (a, b) == (1, 2) it will proceed to the next true condition.
4. In this case, the switch will check only the first value and completely skip the second.
5. The switch will monitor only the second value, and with the first it will create a constant, in this case called “aValue”.
6. Here, I wanted to show that the values can be formed from a variety of parameters, which in the first case is the first value and in the second the second value.
7. This case demonstrates the use of numerical ranges, here switch checks whether the first value will be in the range of 0 to 3 and the other from 0 to 100.

Enums

enum Cases { //1
case noParameters
case oneParameter(text: String)
case anotherOneParameter(firstText: String)
case twoParameters(text: String, number: Int)
}
let thisCase: Cases = .twoParameters(text: "Text", number: 10) //2
switch thisCase {
case .oneParameter(_): //4
break
case .anotherOneParameter(let text): //5
print("Text: \(text)")
case let .twoParameters(text, number): //6
print("Text: \(text)")
print("Number: \(number)")
default: ()
}

1. Declaration of enum with 3 values, the first with no parameters, the second and third with one parameter and the fourth with two parameters.
2. Creating a constant with two parameters.
3. Check if the constant is equal to .noParameters.
4. Check if the constant is equal to .oneParameter and skip values.
5. Check if the constant is equal to .anotherOneParameter, giving access to parameters.
6. The same as in step 5, only the word “let” is now before the name, so you don’t have to write it in front of each parameter.

The code used in this article is on our GitHub.