04. Swift 문법 - Conditional Statements

지금부터 Swift의 조건문에 대해 알아보겠습니다.

 

1. if Statement

if 문은 조건의 참과 거짓을 판단하여 코드를 실행하는 문장입니다.

// if condition {
//     statement
// }

let id = "root"
let password = "1234qwer"

if id == "root" {
    print("valid id")  // => 출력됨
}

if password == "1234qwer" {
    print("valid password")  // => 출력됨
}

// 두 조건을 한번에 비교
if id == "root" && password == "1234qwer" {
    print("go to admin page")  // => 출력됨
}

if id != "root" || password != "1234qwer" {
    print("incorrect value")
}


// if condition {
//     statements
// } else {
//     statements
// }

if id == "root" && password == "1234qwer" {
    // 조건이 참인 경우 실행
    print("go to admin page")
} else {
    // 조건이 거짓인 경우 실행
    print("incorrect value")
}


// if condition {
//     statements
// } else if condition {
//     statements
// } else {
//     statements
// }

let num = 123

// if 문 중첩이 가능함
if num >= 0 {
    print("positive number or zero")
    
    if num % 2 == 0 {
        print("positive even number")
    } else {
        print("positive odd number")
    }
} else {
    print("negative number")
}

// 가장 까다로운(한정된) 조건이 위에 오고 느슨한 조건이 아래로 가도록 해야 함!
if num > 100 {
    print("positive number over 100")
} else if num > 10 {
    print("positive number over 10")
} else if num > 0 {
    print("positive number")
}

 

2. switch Statement

switch 문은 값의 일치 여부에 따라 실행할 코드를 결정하는 문장입니다.

// switch valueExpression {
// case pattern:
//     statements
// case pattern, pattern:
//     statements
// default:
//     statements
// }

let num = 1

// 모든 경우의 수를 처리해야 하기 때문에 default 문을 넣어야 됨
switch num {
case 1:
    print("one")
case 2, 3:
    print("two or three")
default:
    break
}

// => 출력: one

// switch valueExpression {
// case pattern where condition:
//     statements
// default:
//     statements

switch num {
case let n where n <= 10:
    print(n)
default:
    print("others")
}

// => 출력: 1

// Interval Matching
// 범위를 매칭 시키는 것

let temperature = -8

switch temperature {
case ..<10:
    print("Cold")
case 10...20:
    print("Cool")
case 21...27:
    print("Warm")
case 28...:
    print("Hot")
default:
    break
}

// => 출력: Cold

// Fall Through
// 다음 케이스 블록의 결과까지 수행하고 싶을 때 사용 (다음 케이스 조건 검사 x)
// 코드 중복 제거의 장점이 있음

let number = 2

switch number {
case 1:
    print("one")
case 2:
    print("two")
    fallthrough
case 3:
    print("three")
default:
    break
}

// => 출력: two
// => 출력: three

let attempts = 10

switch attempts {
case ..<10:
    print("warning")
case 10:
    print("warning")
    fallthrough
default:
    print("reset")
}

// => 출력: warning
// => 출력: reset

 

3. guard Statement

/*
 # guard Statement
 */

// Early Exit
// : 원하는 조건이 충족되지 않으면 불필요한 코드는 실행하지 않고 일찍 종료하는 것을 말합니다.

// 형태
// gaurd condition else {
//     // condition 이 false 일때 실행되며
//     // 코드의 실행을 중지(종료) 하는 코드 작성
//     statements
// }

// guard optionalBinding else {
//     statements
// }

func validate(id: String?) -> Bool {
    guard let id = id else {
        return false
    }
    
    guard id.count >= 6 else {
        return false
    }
    
    // 한번에 2개 이상 조건 확인 가능
    // guard let id = id, id.count >= 6 else {
    //     return false
    // }
    
    // 문자열이 있고 길이가 6보다 크거나 같은 경우 실행
    print(id)
    return true
}

validate(id: nil)             // 결과: false
validate(id: "hello")         // 결과: false
validate(id: "Good Morning")  // 결과: true


// if vs guard
func validateUsingIf() {
    var id: String? = nil
    
    if let str = id {
        if str.count >= 6 {
            print(str)
        }
    }
    
    // print(str) - 에러
    // if 문 안에서만 str 상수 사용 가능
}

func validateUsingGuard() {
    var id: String? = nil
    
    // 조건이 늘어도 중첩이 없어 코드 가독성이 더 좋음
    guard let str = id else {
        // print(str) - 에러
        return
    }
    guard str.count >= 6 else { return }
    
    print(str)
}

 

4. Value Binding Pattern

/*
 # Value Binding Pattern
 */

// case let name:
// case var name:

let a = 1

switch a {
case let x:
    // a 를 x 라는 상수에 저장 (let x = a = 1)
    // 바인딩 된 상수는 케이스 문 안에서만 사용 가능
    print(x)
}

// 출력: 1

switch a {
case var x where x > 100:
    x = 200
    print(x)
default:
    break
}

// 출력: 1

let pt = (1, 2)

switch pt {
case let(x, y):
    print("x: \(x), y: \(y)")
case (let x, let y):
    print(x, y)
case (let x, var y):
    print(x, y)
case let(x, _):
	// 튜플에서 사용하지 않는 상수는 _ 로 생략 가능
    print(x)
}

// 출력: x: 1, y: 2

 

5. Expression Pattern

/*
 # Expression Pattern
 */

let a = 1

switch a {
case 0...10:
    print("0 ~ 10")
default:
    break
}


// Pattern Matching Operator
// a ~= b

struct Size {
    var width = 0.0
    var height = 0.0
    
    // (case 키워드 다음에 오는 pattern 의 타입, switch 키워드 다음에 오는 valueExpression 의 타입)
    // 이 경우는 width 가 해당 범위에 포함되면 true 로 처리함.
    static func ~=(left: Range<Int>, right: Size) -> Bool {
        return left.contains(Int(right.width))
    }
}

let s = Size(width: 10, height: 20)

switch s {
case 1..<10:
    print("1 ~ 9")
case 10..<100:
    print("10 ~ 99")
default:
    break
}

// 출력: 10 ~ 99

---

지금까지 Swift 의 조건문 (Conditional Statements)에 대해 간략하게 알아보았습니다.