Welcome to FutureAppLaboratory

v=（*＾ワ＾*）=v

Learning Swift Part 5 - Control Flow

| Comments

Just some notes after reading Apple’s official online guide. Most code are from the guide, with some modification by me.

Tuple in switch statement is interesting.

===== Full Notes =====

Control Flow

Time to be Awesome - awesome.rb 
1

puts "Awesome!" unless lame

For-In

  • Sample
1
2
3
4
5
6
7
8

    for index in 1...5 {
        println("\(index) times 5 is \(index * 5)")
    }
    // 1 times 5 is 5
    // 2 times 5 is 10
    // 3 times 5 is 15
    // 4 times 5 is 20
    // 5 times 5 is 25
  • if no need of value from the range
1
2
3
4
5
6
7
8

    let base = 3
    let power = 10
    var answer = 1
    for _ in 1...power {
        answer *= base
    }
    println("\(base) to the power of \(power) is \(answer)")
    // prints "3 to the power of 10 is 59049"
  • Use in array
1
2
3
4
5
6
7
8

    let names = ["Anna", "Alex", "Brian", "Jack"]
    for name in names {
        println("Hello, \(name)!")
    }
    // Hello, Anna!
    // Hello, Alex!
    // Hello, Brian!
    // Hello, Jack!
  • Use in dictionary
1
2
3
4
5
6
7

    let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
    for (animalName, legCount) in numberOfLegs {
        println("\(animalName)s have \(legCount) legs")
    }
    // spiders have 8 legs
    // cats have 4 legs
    // ants have 6 legs
  • Use in string
1
2
3
4
5
6
7
8

    for character in "Hello" {
        println(character)
    }
    // H
    // e
    // l
    // l
    // o
  • For
    • Sample
1
2
3
4
5
6

        for var index = 0; index < 3; ++index {
            println("index is \(index)")
        }
        // index is 0
        // index is 1
        // index is 2

- Index is only accessible in the loop

1
2
3
4
5
6
7
8
9

        var index: Int
        for index = 0; index < 3; ++index {
            println("index is \(index)")
        }
        // index is 0
        // index is 1
        // index is 2
        println("The loop statements were executed \(index) times")
        // prints "The loop statements were executed 3 times"
  • While Loops
    • Snakes and Ladders
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

        let finalSquare = 25
        var board = [Int](count: finalSquare + 1, repeatedValue: 0)

        board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
        board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08

        var square = 0
        var diceRoll = 0
        while square < finalSquare {
            // roll the dice
            if ++diceRoll == 7 { diceRoll = 1 }
            // move by the rolled amount
            square += diceRoll
            if square < board.count {
                // if we're still on the board, move up or down for a snake or a ladder
                square += board[square]
            }
        }
        println("Game over!")
  • Do-While
    • Snakes and Ladders
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

        let finalSquare = 25
        var board = [Int](count: finalSquare + 1, repeatedValue: 0)
        board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
        board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
        var square = 0
        var diceRoll = 0

        do {
            // move up or down for a snake or ladder
            square += board[square]
            // roll the dice
            if ++diceRoll == 7 { diceRoll = 1 }
            // move by the rolled amount
            square += diceRoll
        } while square < finalSquare
        println("Game over!")
  • If
    • Sample
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

        var temperatureInFahrenheit = 30
        if temperatureInFahrenheit <= 32 {
            println("It's very cold. Consider wearing a scarf.")
        }
        // prints "It's very cold. Consider wearing a scarf."

        temperatureInFahrenheit = 40
        if temperatureInFahrenheit <= 32 {
            println("It's very cold. Consider wearing a scarf.")
        } else {
            println("It's not that cold. Wear a t-shirt.")
        }
        // prints "It's not that cold. Wear a t-shirt."

        temperatureInFahrenheit = 90
        if temperatureInFahrenheit <= 32 {
            println("It's very cold. Consider wearing a scarf.")
        } else if temperatureInFahrenheit >= 86 {
            println("It's really warm. Don't forget to wear sunscreen.")
        } else {
            println("It's not that cold. Wear a t-shirt.")
        }
        // prints "It's really warm. Don't forget to wear sunscreen."

        temperatureInFahrenheit = 72
        if temperatureInFahrenheit <= 32 {
            println("It's very cold. Consider wearing a scarf.")
        } else if temperatureInFahrenheit >= 86 {
            println("It's really warm. Don't forget to wear sunscreen.")
        }
  • Switch
    • Sample
1
2
3
4
5
6
7
8
9

        switch some value to consider {
        case value 1:
            respond to value 1
        case value 2,
        value 3:
            respond to value 2 or 3
        default:
            otherwise, do something else
        }

- Use with char

1
2
3
4
5
6
7
8
9
10
11

        let someCharacter: Character = "e"
        switch someCharacter {
        case "a", "e", "i", "o", "u":
            println("\(someCharacter) is a vowel")
        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
        "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
            println("\(someCharacter) is a consonant")
        default:
            println("\(someCharacter) is not a vowel or a consonant")
        }
        // prints "e is a vowel"

- No Implicit Fallthrough

    In contrast with switch statements in C and Objective-C, switch statements in Swift do not fall through the bottom of each case and into the next one by default. Instead, the entire switch statement finishes its execution as soon as the first matching switch case is completed, without requiring an explicit break statement. This makes the switch statement safer and easier to use than in C, and avoids executing more than one switch case by mistake.

- Bad case

1
2
3
4
5
6
7
8
9

        let anotherCharacter: Character = "a"
        switch anotherCharacter {
        case "a":                       // Each case must contain at least one executable statement.
        case "A":
            println("The letter A")
        default:
            println("Not the letter A")
        }
        // this will report a compile-time error

- Range Matching

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

        let count = 3_000_000_000_000
        let countedThings = "stars in the Milky Way"
        var naturalCount: String
        switch count {
        case 0:
            naturalCount = "no"
        case 1...3:
            naturalCount = "a few"
        case 4...9:
            naturalCount = "several"
        case 10...99:
            naturalCount = "tens of"
        case 100...999:
            naturalCount = "hundreds of"
        case 1000...999_999:
            naturalCount = "thousands of"
        default:
            naturalCount = "millions and millions of"
        }

- Tuple

1
2
3
4
5
6
7
8
9
10
11
12
13
14

        let somePoint = (1, 1)
        switch somePoint {
        case (0, 0):
            println("(0, 0) is at the origin")
        case (_, 0):
            println("(\(somePoint.0), 0) is on the x-axis")
        case (0, _):
            println("(0, \(somePoint.1)) is on the y-axis")
        case (-2...2, -2...2):
            println("(\(somePoint.0), \(somePoint.1)) is inside the box")
        default:
            println("(\(somePoint.0), \(somePoint.1)) is outside of the box")
        }
        // prints "(1, 1) is inside the box"

- Value Bindings

1
2
3
4
5
6
7
8
9
10

        let anotherPoint = (2, 0)
        switch anotherPoint {
        case (let x, 0):
            println("on the x-axis with an x value of \(x)")
        case (0, let y):
            println("on the y-axis with a y value of \(y)")
        case let (x, y):
            println("somewhere else at (\(x), \(y))")
        }
        // prints "on the x-axis with an x value of 2"

- Where

1
2
3
4
5
6
7
8
9
10

        let yetAnotherPoint = (1, -1)
        switch yetAnotherPoint {
        case let (x, y) where x == y:
            println("(\(x), \(y)) is on the line x == y")
        case let (x, y) where x == -y:
            println("(\(x), \(y)) is on the line x == -y")
        case let (x, y):
            println("(\(x), \(y)) is just some arbitrary point")
        }
        // prints "(1, -1) is on the line x == -y"
  • Control Transfer Statements
    • Continue
      The continue statement tells a loop to stop what it is doing and start again at the beginning of the next iteration through the loop. It says “I am done with the current loop iteration” without leaving the loop altogether.
1
2
3
4
5
6
7
8
9
10
11
12

        let puzzleInput = "great minds think alike"
        var puzzleOutput = ""
        for character in puzzleInput {
            switch character {
            case "a", "e", "i", "o", "u", " ":
                continue
            default:
                puzzleOutput.append(character)
            }
        }
        println(puzzleOutput)
        // prints "grtmndsthnklk"

- Break

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

        let numberSymbol: Character = "三"  // Simplified Chinese for the number 3
        var possibleIntegerValue: Int?
        switch numberSymbol {
        case "1", "١", "一", "๑":
            possibleIntegerValue = 1
        case "2", "٢", "二", "๒":
            possibleIntegerValue = 2
        case "3", "٣", "三", "๓":
            possibleIntegerValue = 3
        case "4", "٤", "四", "๔":
            possibleIntegerValue = 4
        default:
            break
        }
        if let integerValue = possibleIntegerValue {
            println("The integer value of \(numberSymbol) is \(integerValue).")
        } else {
            println("An integer value could not be found for \(numberSymbol).")
        }
        // prints "The integer value of 三 is 3."

- Explicit Fallthrough  
The fallthrough keyword does not check the case conditions for the switch case that it causes execution to fall into. The fallthrough keyword simply causes code execution to move directly to the statements inside the next case (or default case) block, as in C’s standard switch statement behavior.

1
2
3
4
5
6
7
8
9
10
11

        let integerToDescribe = 5
        var description = "The number \(integerToDescribe) is"
        switch integerToDescribe {
        case 2, 3, 5, 7, 11, 13, 17, 19:
            description += " a prime number, and also"
            fallthrough
        default:
            description += " an integer."
        }
        println(description)
        // prints "The number 5 is a prime number, and also an integer."

- Labeled Statements

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

        gameLoop: while square != finalSquare {
            if ++diceRoll == 7 { diceRoll = 1 }
            switch square + diceRoll {
            case finalSquare:
                // diceRoll will move us to the final square, so the game is over
                break gameLoop
            case let newSquare where newSquare > finalSquare:
                // diceRoll will move us beyond the final square, so roll again
                continue gameLoop
            default:
                // this is a valid move, so find out its effect
                square += diceRoll
                square += board[square]
            }
        }
        println("Game over!")

Comments