[Swift] Control Flow 1-2 - 조건구문 (if, switch, guard)

조건적 구문 (Conditional Statements)

Swift에서는 if와 switch문 두가지의 조건문을 제공 합니다.

간단한 조건문에서는 if를,

좀더 복잡한 구조에서는 switch를 사용하는게 좋습니다.

 

if 문

 

예시) if 

var temperature = -10
if temperature <= 0 {
    print("It's very cold. Consider wearing a scarf.")
}
// It's very cold. Consider wearing a scarf.

 

예시)  else 

var temperature = 8
if temperature <= 0 {
    print("It's very cold. Consider wearing a scarf.")
} else {
    print("It's not that cold. Wear a t-shirt.")
}
// It's not that cold. Wear a t-shirt.

 

예시)  else, else-if 

var temperature = 32
if temperature <= 0 {
    print("It's very cold. Consider wearing a scarf.")
} else if temperature >= 30 {
    print("It's really warm. Don't forget to wear sunscreen.")
} else {
    print("It's not that cold. Wear a t-shirt.")
}
// It's really warm. Don't forget to wear sunscreen.

 

예시) else-if 

var temperature = 22
if temperature <= 0 {
    print("It's very cold. Consider wearing a scarf.")
} else if temperature >= 30 {
    print("It's really warm. Don't forget to wear sunscreen.")
}

// 결과값 x 
// if조건과 else if 조건 어디에도 포함되지 않기 때문

 

Switch 문

switch문의 형태는 다음과 같습니다.

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
}

 

switch에 참고할 값을 넣고

case 에는 분기 할 값을 넣은뒤, 각 case 마다 분기 처리를 하면되고, (if문의 if와 else if와 비슷한 개념)

어떤 case에도 해당이 되지않는다 할때는 default 처리를 해주면 됩니다. (if문의 else와 비슷한 개념)

 

다만, default 키워드 없이도 모든 경우가 커버 된다면, default를 생략할 수 있습니다.

 

let someCharacter: Character = "z"
switch someCharacter {
case "a":
    print("첫번째 알파벳")
case "z":
    print("마지막 알파벳")
default:
    print("나머지 알파벳")
}
// 마지막 알파벳

 

암시적인 진행을 사용하지 않음 (No Implicit Fallthrough)

C와 Objective-C와는 달리 Swift의 switch문에서는 암시적인 진행을 하지 않습니다.

break 문을 요구하지 않으며, 첫번째로 일치하는 swich case가 완료되면 구문을 종료합니다.

 

NOTE

Swift에서 break를 요구하진 않지만 case안에 특정 지점에서 멈추도록 하기 위해 break를 사용할 수도 있습니다.

 

 

각 case마다 최소 하나 이상의 실행구문을 꼭 가지고 있어야 합니다. 

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a": // 에러! 실행구문이 없음
case "A":
    print("The letter A")
default:
    print("Not the letter A")
}

 

 

case에 콤마(,)를 사용해서 묶어서 case문을 만들 수 있습니다.

let anotherCharacter: Character = "A"
switch anotherCharacter {
case "a", "A":
    print("알파벳 a")
default:
    print("a가 아님 ㅠ")
}
// 알파벳 a

 

 

인터벌 매칭(Interval Matching)

숫자의 범위를 조건으로 사용할 수 있습니다.

let count = 62
let countedThings = "토성을 도는 위성들이"
let naturalCount: String
switch count {
case 0:
    naturalCount = "없다."
case 1..<5:
    naturalCount = "조금 있다."
case 5..<12:
    naturalCount = "몇대 있다."
case 12..<100:
    naturalCount = "수십대 있다."
case 100..<1000:
    naturalCount = "몇백대 있다"
default:
    naturalCount = "많다"
}
print(" \(countedThings) \(naturalCount)")
//  토성을 도는 위성들이 수십대 있다.

 

 

튜플 (Tuples)

튜플 조건으로 사용할 수 있습니다.

wildcard 패턴으로 알려져있는 언더바 ( _ ) 를 사용하여  모든값과 일치 시킵니다.

 

(문제 포함)

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

// 답은?

답: (1, 1) is on th x-axis

 

1. 조건에 해당하는 case를 만나게 되면 실행후 switch문은 종료되고,

2. 튜플은 가장 첫번째 값이 true일때만 다음 값과 비교를 시작하고 

3. 위에 언급했던 언더바 ( _ )는 wildcard 패턴으로 모든값과 매치 시킴으로

case (1, _) 가 실행되고 switch문은 종료 됩니다.

 

 

값 바인딩(Value Bindings)

값 바인딩이란 변수 또는 상수에 매치된 값을 할당하는 것 입니다.

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):
    print("somewhere else at (\(x), \(y))")
}
// on the x-axis with an x value of 2"

 

위 세개의 case에서 일시적으로 하나 또는 두개의 값을 갖는 상수 x와 y를 선언했습니다. 

첫째 case (let x, 0)은 y의 값이 0으로 anotherPoint의 두번째 값과 일치하므로 let x에 2라는 임시 상수를 할당 합니다.

마찬가지로, 두번째 case (0, let y)도 y의 값에는 0을 할당하지만 x값이 anotherPoint와 일치하지 않으므로 pass.

위 switch문은 default가 필요없습니다. 마지막 case에서 모든 경우가 커버되기 때문이죠.

 

 

Where

case에 where 조건을 사용할 수 있습니다.

let yetAnotherPoint = (1, -1)
switch yetAnotherPoint {
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 arbitary point")
}

// 1, -1 is on the line x == -y

 

상수 (x, y) 값은 각각 임시 값으로 (1, -1) 이라는거는 위에서 배웠습니다.

case로 분류 해놓은 상태에서 where문을 사용해서 조건을 사용할 수 있습니다.

첫번째 case는 let (1, -1) 이 같지 않음으로 pass

두번째 case는 let (1, -1)에 where문을 보면 x == -y 에서 -y . 즉, -y는 1이 되어 x == y 의 조건문에 적합하여 두번째 case가 실행이 됩니다.

마지막 case에 모든 경우의 수가 포함이 됨으로 default를 사용하지 않은것도 볼 수 있습니다. 

 

혼합 케이스(Compound Cases)

case에 콤마(,)로 구분해 여러 조건을 혼합해 사용할 수 있습니다.

 

let someCharacter: Character = "b"
switch someCharacter {
case "a", "e", "i", "o", "u":
    print("\(someCharacter) 는 모음 입니다.")
    
case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
     "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
    print("\(someCharacter) 는 자음 입니다.")
    
default:
    print("\(someCharacter) 은(는) 영어가 아닙니다.")
}
// b 는 자음 입니다.

 

혼합 케이스에서도 값 바인딩(Value Bindings)를 사용할 수 있습니다.

let stillAnotherPoint = (9, 0)
switch stillAnotherPoint {
case (let distance, 0), (0, let distance):
    print("On as axis, \(distance) from the origin")
    
default:
    print("Not on an axis")
}
// On as axis, 9 from the origin

혼합케이스에서 모든 패턴은 값 바인딩의 같은 집합을 포함해야 하고 각 바인딩은 혼합 케이스에 모든패턴으로 부터 같은 타입의 값을 얻어야 합니다. 

 

위 두가지 패턴에서 (let distance, 0)은 x축이 일치하고 (0, let distance)는 y축이 일치 합니다. 

두 패턴 모두 distance 바인딩을 포함하고, 두 distance의 타입은 정수 입니다.

즉, case의 바디 코드는 항상 distance로 값에 접근 할 수 있다는 의미입니다. 

 

---

제어 변경 구문 (Control Transfer Statements)

제어 변경 구문은 코드의 진행을 계속 할지 말지를 결정하거나, 코드가 실행되는 순서를 바꾸기 위해 사용합니다. 

Swift에서는 아래 5가지의 제어 변경 구문을 제공합니다.

• continue
• break
• fallthrough
• return
• throw

continue 

continue 구문은 현재 작업을 멈추고 다음 반복을 시작 하기 위해 부릅니다.

let puzzleInput = "great minds think alike"
var puzzleOutput = ""
let charactersToRemove: [Character] = ["a", "e", "i", "o", "u", " "]

for character in puzzleInput {
    if charactersToRemove.contains(character) {
        continue
    }
        puzzleOutput.append(character)
    
}
print(puzzleOutput)
// grtmndsthnklk

 

puzzleInput 에 있는 내용을 하나씩 돌리면서 

charactersToRemove 의 값이 포함되어 있으면 

puzzleOutput.append(character) 구문을 실행 시키지 않고  반복문을 다시 돌린다. 

그렇게 반복문을 돌아 완성된 결과값은

grtmndsthnklk

모음과, 공백을 제외 시킨 값이 나온다.

 

Break

break문은 전체 제어문의 실행을 중지 시킵니다. 

반복문 이나 switch에 사용할 수 있습니다.

 

반복문 안에 Break (Break in a Loop Statement)

• 반복문 안에 break를 사용할 때 즉시 종료시키며, 반복문을 닫는 중괄호 { } 후의 첫번째 코드로 이동

Switch 안에 Break (Break in a Switch Statement)

• Switch문 안에 break는 즉시 종료시키며, switch문을 닫는 중괄호 { } 후의 첫번째 코드로 이동.

 

let numberSymbol: Character = "5" 
var possibleIntegerValue: Int?
switch numberSymbol {

case "1", "١", "一", "๑":
    possibleIntegerValue = 1
    
case "2", "٢", "二", "๒":
    possibleIntegerValue = 2
    
case "3", "٣", "三", "๓":
    possibleIntegerValue = 3
    
case "4", "٤", "四", "๔":
    possibleIntegerValue = 4
    
case "5":
    break
    
default:
    break
}


if let integerValue = possibleIntegerValue { // integerValue의 값이 있으면 if문으로, 없으면 (optional) else 구문으로
    print("The integer value of \(numberSymbol) is \(integerValue).")
} else {
    print("An integer value could not be found for \(numberSymbol).")
}

// An integer value could not be found for 5.

 

 

Fallthrough

Swift의 Switch문에서 해당하는 case 가 실행되면 Switch문이 종료가 됩니다.

C언어에서는 break를 쓰지 않으면 다음 걸로 넘어갑니다. 

이처럼, Swift도 해당 case가 실행되도 다음 case를 실행하고 싶으면 Fallthrough 키워드를 사용합니다.

 

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."
}
print(description)
// "The number 5 is a prime number, and also an integer."

 

상수 integerToDescribe 가 첫번째 case에 포함이되어 실행 되지만, fallthrough 키워드로 인해 이어서 default 부분도 실행됩니다.

 

 

레이블(표기) 구문(Labeled Statements)

반복문을 중첩하여 사용하거나, 반복문과 switch문을 사용할때, 해당 반복문이나 switch문에 이름을 지어줌 으로써, 특정구문을 break나 continue를 사용하여 빠르게 구문을 종료하거나, 계속 루프를 돌릴 수 있습니다.  

 

// break 사용

outSide: for i in 1...3 {
    print("OutSide Loop", i)
    
inside: for j in 1...3 {
        print("inside Loop", j)
        
        break outSide // outside에 해당하는 부분 종료.
    }
}
//  OutSide Loop 1
//  inside Loop 1

 

// continue

outSide: for i in 1...3 {
    print("OutSide Loop", i)
    
inside: for j in 1...3 {
        print("inside Loop", j)
        
        continue outSide // continue 키워드로 inside 구문은 한번만 실행되고 outSide 반복문으로 루프돌림
    }
}

// OutSide Loop 1
// inside Loop 1
// OutSide Loop 2
// inside Loop 1
// OutSide Loop 3
// inside Loop 1

 

Labeled Statements는 이럴때 사용합니다.

원하는 문장을 제어 하고 싶을때 !! 

 

 

Early Exit (guard)

guard문을 이용해 특정 조건을 만족하지 않으면 이후 코드를 실행하지 않도록 방어코드를 작성할 수 있습니다.

 

// age가 없는경우

func greet(person: [String: String]) {
    guard let name = person["name"] else {
        print("근데 이름이 뭐니")
        return
    }
    print("안녕 \(name)!")                // 인자에 name이 있으므로 해당 print실행
    
    guard let location = person["location"] else {
        print("근데 어디사니")
        return
    }
    print("오 \(location) 좋지")           // 인자에 location이 있으므로 해당 print실행
    
    guard let age = person["age"] else {
        print("근데 몇살이니")               // 인자에 age가 없으므로 해당 print실행 후 return
        return
    }
    print("\(age)살 이구나.. 그렇구나..")
}

greet(person: ["name": "Roy", "location": "Seoul"])
// 안녕 Roy!
// 오 Seoul 좋지
// 근데 몇살이니

 

위 코드를 보면 가장 밑부분에 함수호출에 다른 인자들은 다 있지만 (name, location),

age 만 없어 아래 구문을 통과하지 못하고 "근데 몇살이니" 부분이 출력된걸 볼 수 있습니다. 

 

 

---