5. 제어 흐름

for, while, if, guard, switch, break, continue

다른 언어와 거의 동일하다고 봐도 무방하다.

1. For-In 루프

배열, 숫자 범위, 문자열, 딕셔너리, ... 에 for - in 루프를 적용해서 요소 하나하나에 접근할 수 있다.

앞 내용에서 대체로 다뤘었고, 익숙하기 때문에 내가 너무나도 잘 잊어버리는

for (index, value) in enumarated(arr) {
}

for i in stride(from: 0, to: 10, by: 2) { 
    // 10 은 포함 안됨.
}

for i in stride(from: 0, through: 10, by: 2) { 
    // 10 포함.
}

만 쓰고 넘어가도록 하겠다. 파이썬에서는 enumerate(arr) / range(0, 10, 2) 이라 항상 헷갈림

2. while / repeat ~ while

다른 언어의 while, do ~ while 과 같다. 조건이 true 인 동안 반복 / 첫번째는 조건 따지지 않고 실행 후 반복.

3. 조건문

1. if ~ else if ~ else

2. switch ⭐️

Swift switch 의 특징

• swift 는 break 를 적지 않아도 된다.
  다른 언어에서는 케이스마다 break 를 걸어주지 않으면 다음것까지 모두 실행되지만, Swift 는 아님. 오히려, 원래처럼 아래 케이스까지 실행되게 하고 싶으면, fallthrough 를 명시적으로 써준다. ⭐️

• switch 문에 정수나 문자만이 아니라, 튜플, enum 같은 것들을 넣을 수 있다.

switch int(score / 10) {
case 10, 9: print("A") // , 로 나누기도 가능.
case 8: print("B")
case 7: print("C")
case 6: print("D")
default: print("F")
}

// 숫자 범위로 쓰는 것도 가능하다.
switch score {
case 90...100: print("A")
case 80..<90: print("B")
case 70..<80: print("C")
case 60..<70: print("D")
default: print("F")
}

3. switch - tuple / where ⭐️

case 를 무시하려면 _ 로 넣어주면 된다.

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

값을 바인딩해서 사용할 수도 있고, where 절을 이용해서 바인딩한 값의 조건을 따질 수도 있다.

let anotherPoint = (2, 0)
switch anotherPoint {
case (let x, 0):
    print("on the x-axis with an x value of \(x)")
case (0, let y):
    print("on the y-axis with a y value of \(y)")
case let (x, y) where x == y:
    print("(\(x), \(y)) is on the line x == y")
case let (x, y) where x == -y:
    print("(\(x), \(y)) is on the line x == -y")
case let (x, y):
    print("(\(x), \(y)) is just some arbitrary point")
}
// Prints "on the x-axis with an x value of 2"

4. 제어 변경 구문

continue, break, fallthrough, return(함수), throw(에러 핸들링)

1. continue

현재 반복하고 있는 단계를 건너뛰고, 다음 반복을 시작.

2. break ⭐️

현재 반복문을 빠져나감.
or switch 문에서 break 앞에 있는 조건을 제외한 것을 무시. default: break

3. fallthrough

switch 문이 C 처럼 동작할 수 있게, 다음 단계로 흐르게 만들어준다.

+) 라벨을 이용해서 특정 반복문을 빠져나갈 순 있지만, 잘 안 쓰임.

gameLoop: while square != finalSquare {
    diceRoll += 1
    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]
    }
}
print("Game over!")

5. Early Exit (guard) ⭐️

함수나 클로저 내에서, 어떤 조건을 만족해야하는 변수에 따라 다음 문장의 실행을 결정한다.
📕 해당 변수를 할당하는 문장을 검사해서 true 이면 다음 문장을 실행하고, 그 조건이 거짓이 되면 상위 블록을 탈출하는 문장을 else 문에 작성한다.
📕 보통은 else 문에서 return 이 사용되지만, 상황에 따라 break continue throw 모두 사용 가능. 탈출이니까~
📕 예외 상황만을 처리하고 싶을 때 if 대신 guard 를 사용한다.

func greet(person: [String: String]) {
    // 딕셔너리에 name 이 없으면 그냥 끝남.
    guard let name = person["name"] else { return }

    print("Hello \(name)!")

    // 딕셔너리에 위치 정보가 없으면 이름, 안내문구만 뽑고 끝남.
    // 옵셔널 바인딩도 가능.
    guard let location = person["location"] else {
        print("I hope the weather is nice near you.")
        return
    }

    print("I hope the weather is nice in \(location).")
}

// OS 버젼에서 가능한 API 인지 체크해서 사용하는데 사용한다.
// guard 문으로도 사용 가능
if #available(iOS 10, macOS 10.12, *) {
    // Use iOS 10 APIs on iOS, and use macOS 10.12 APIs on macOS
} else {
    // Fall back to earlier iOS and macOS APIs
}

6. 함수

특정 작업을 수행하는 코드 블럭.
보통 같은 기능을 하면서 두번 이상 반복되는 것을 묶어서 함수로 만든다.

함수 이름, 인자, 반환 타입, 반환값이 있는 형태로 다른 언어의 함수와 구조는 동일하기 때문에, Swift 함수의 특이한 점만 정리하겠다.

1. 인자 이름에 라벨을 준다 ⭐️

func greet(person name: String) -> String {
    return "Hello, " + name + "!";
}

함수를 호출하면서 파라미터를 넘겨줄 때 사용하는 이름과 함수 내부에서 해당 인자를 사용하는 이름이 다르다.
함수 외부에서 파라미터 이름 라벨을 생략하고 싶으면 _ 를 사용한다.

📕 원래 안되는 키워드도 `parametername` 처럼 ` 를 붙여서 주면 대부분의 이름을 파라미터 이름으로 사용할 수 있다.

2. tuple? 을 반환할 수 있다.

사실 이건 다른 언어에서도 가능하지만, tuple 에 라벨을 줄 수 있다는 것은 특이하다.
그리고 튜플에 대한 옵셔널을 반환할 수 있다는건 특이하다.

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("min is \(bounds.min) and max is \(bounds.max)") 
// 반환하는 튜플의 값을 라벨 이름으로 사용.
// Prints "min is -6 and max is 109"

3. 함수 바디가 한줄이면, 암시적 return 이 된다.

4. 기본값을 줄 수 있다.

func addTwo(first: Int, second: Int = 2) {
    return first + second
}

addTwo(first: 1) // 3
addTwo(first: 10, second: 3) // 13

📕 기본 값이 없는 매개변수를 기본 값이 있는 것보다 앞에 배치하는 것이 좋고,
기본 값 여부와 상관없이 더 중요한 값을 앞에 배치하는 것이 좋다.

5. 가변 파라미터

같은 타입의 파라미터가 여러개 들어올 수 있을 때,
인자 타입을 Type... 으로 지정해주면, 해당 타입의 0개 이상의 인자가 들어올 수 있다.

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers

6. inout 파라미터

함수 안에서 복사값이 바뀌니까, C 의 포인터를 이용해 주소값을 넘겨서 바꾸는 것처럼
inout 키워드를 넣어서, 함수 밖의 값이 바뀔수 있게 해준다.

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var num1 = 0
var num2 = 1
swapTwoInts(&num1, &num2)

📕 함수형 프로그래밍 패러다임에서는 지양하는 것이 좋다.

1. 함수가 호출 될 때 전달인자의 값을 복사하고
2. 복사한 것을 함수 내부에서 값을 변경
3. 함수가 반환하면서 변경된 값을 원래 매개변수에 할당

-> Memory Safety 를 보장하지 않을 수 있음.

📕 inout 은 기본값 X, 가변 파라미터 X

7. 함수 타입

함수를 type 으로 사용할 수 있다.

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}

// 변수에 함수를 할당 가능.
var mathFunction: (Int, Int) -> Int = addTwoInts

인자로 함수를 넘겨줄 수 있음.

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// Prints "Result: 8"

함수를 반환할 수도 있음.

func stepForward(_ input: Int) -> Int {
    return input + 1
}
func stepBackward(_ input: Int) -> Int {
    return input - 1
}

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

8. 중첩 함수

함수 안에 함수를 정의할 수 있다. 그러면 그 함수를 사용할 수 있는 범위는 커다란 함수 안!

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backward ? stepBackward : stepForward
}

📕 9. 종료되지 않는 함수 Never

• 정상적으로 끝나지 않는 함수. == 비반환 함수
• 오류를 던진다던가, 오류를 보고하고 프로세스를 종료해버리기 때문.
• guard 문의 else 블록에서도 호출 가능
• 대표적인 예시가 fatalError

func crashAndBurn() -> Never {
    fatalError("fatal error")
}

📕 10. 반환 값을 무시할 수 있는 함수

• 함수의 반환값을 사용하지 않는 경우, 컴파일러 경고를 없애주는 코드 @discardableResult

@discardableResult func discardableResultSay(_ something: String) -> String {
    print(something)
    return something
}

discardableResultSay("hi") // 반환값을 사용하지 않지만 컴파일러 경고 안뜸.