[Swift] Control Flow

 

 

Control Flow

---

 

Swift에서는 while loop, if guard, switch, for-in 문 등 많은 제어문을 제공한다.

 

For-In 문

 

for-in문은 배열, 숫자, 문자열을 순서대로 순회(iterate)하기위해 사용한다.

let names = ["Anna", "Alex", "Brian", "Jack"]
for name in names {
    print("Hello, \(name)!")
}
// Hello, Anna!
// Hello, Alex!
// Hello, Brian!
// Hello, Jack!

 

사전에서 반환된 key-value쌍으로 구성된 튜블을 순회하면서 제어할 수도 있다.

하지만 사전은 순서대로 정렬이 되지 않기때문에, 사전에 기입한 순서대로 순회하지않는다.

let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]
for (animalName, legCount) in numberOfLegs {
    print("\(animalName)s have \(legCount) legs")
}
// ants have 6 legs
// spiders have 8 legs
// cats have 4 legs

 

for-in 문을 순서대로 제어할 필요가 없다면, 변수 자리에 _ 키워드를 사용해 성능을 높일 수 있다.

let base = 3
let power = 10
var answer = 1
for _ in 1...power {
    answer *= base
}
print("\(base) to the power of \(power) is \(answer)")
// Prints "3 to the power of 10 is 59049"

 

범위 연산자를 사용할 수 있고, stride(from:to:by:), stride(from:through:by:)함수와 함께 사용할 수 있다.

let minutes = 60
for tickMark in 0..<minutes {
    // render the tick mark each minute (60 times)
}

//stride(from:to:by:) 끝 미포함
let minuteInterval = 5
for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {
    // render the tick mark every 5 minutes (0, 5, 10, 15 ... 45, 50, 55)
}

//stride(from:through:by:) 끝 포함
let hours = 12
let hourInterval = 3
for tickMark in stride(from: 3, through: hours, by: hourInterval) {
    // render the tick mark every 3 hours (3, 6, 9, 12)
}

 

While 문

 

Swift에서는 while과 repeat-while 두 가지 종류의 while 문을 지원한다.

 

while

while condition {
    statements
}

 

조건(Condition)이 거짓(false)일 때 까지 구문(statements)을 반복한다.

 

repeat while

repeat {
    statements
} while condition

repeat while은 다른 언어의 do while 과 유사하다.

구문(statements)을 최소 한번 이상 실행하고 while 조건이 거짓일 때까지 반복한다.

 

 

조건적 구문

 

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

 

if 문

 

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

 

 

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
}

 

Example

 

let someCharacter: Character = "z"
switch someCharacter {
case "a":
    print("The first letter of the alphabet")
case "z":
    print("The last letter of the alphabet")
default:
    print("Some other character")
}
// Prints "The last letter of the alphabet"

 

Swift의 switch 문은 암시적 진행(Implicit Fallthrough)을 사용하지 않는다. 

 

C와 Objective-C의 switch 구문과는 달리 Swift의 switch구문은 암시적인 진행을 하지 않는다다.

C나 Objective-C에서는 switch 구문이 기본적으로 모든 case를 순회하여 default를 만날 때까지 진행된다.

그렇게 진행하지 않기 위해 break라는 문구를 명시적으로 적어야 했지만, Swift에서는 break를 적지 않아도 특정 case가 완료되면 자동으로 switch구문을 빠져 나오게 된다.

이로 인해 실수로 break를 적지않아 의도하지 않은 case문이 실행되는 것을 방지해준다.

비록 break가 Swift에서 필수적이지는 않지만 case안에 특정 지점에서 멈추도록 하기 위해 break를 사용할 수 있다.

 

 

Example

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a": // case문에 body가 없으므로 에러가 발생합니다.
case "A":
    print("The letter A")
default:
    print("Not the letter A")
}
// 컴파일 에러


let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a", "A": //case안에 콤마로 구분하여 혼합 사용 가능
    print("The letter A")
default:
    print("Not the letter A")
}
// Prints "The letter A"

// 숫자의 특정 범위를 조건으로 사용 가능
let approximateCount = 62
let countedThings = "moons orbiting Saturn"
let naturalCount: String
switch approximateCount {
case 0:
    naturalCount = "no"
case 1..<5:
    naturalCount = "a few"
case 5..<12:
    naturalCount = "several"
case 12..<100:
    naturalCount = "dozens of"
case 100..<1000:
    naturalCount = "hundreds of"
default:
    naturalCount = "many"
}
print("There are \(naturalCount) \(countedThings).")
// Prints "There are dozens of moons orbiting Saturn."


// 튜플을 조건으로 사용 가능
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) 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"

 

값 바인딩

 

특정 x, y 값을 각각 다른 case에 정의하고 그 정의된 상수를 또 다른 case에서 사용할 수 있다.

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))")
}
// Prints "on the x-axis with an x value of 2"

 

 

where 문

 

where을 통해 case에 특정 조건 가능

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 arbitrary point")
}
// Prints "(1, -1) is on the line x == -y"

 

제어 전송 구문

 

제어 전송 구문은 코드의 진행을 계속 할지 말지를 결정하거나, 실행되는 코드의 흐름을 바꾸기 위해 사용한다.

• continue
• break
• fallthrough
• return
• throw

 

continue

 

continue문은 현재 loop를 중지하고 다음 loop를 수행하도록 한다.

 

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 // charactersToRemove에 character가 포함되어있을 경우 for문의 한단계 탈출
    } else {
        puzzleOutput.append(character)
    }
}
print(puzzleOutput)
// Prints "grtmndsthnklk"

 

Break 

 

break문은 전체 제어문의 실행을 즉각 중지 시킨다.  loop나 switch문에서 사용할 수 있다.

let numberSymbol: Character = "三"  // 중국어로 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 {
    print("The integer value of \(numberSymbol) is \(integerValue).")
} else {
    print("An integer value could not be found for \(numberSymbol).")
}

 

 

 

 

fallthrough

 

fallthrough 키워드는 이후의 case에 대해서도 실행하게한다. Swift에선 자동으로 break가 사용되지만, fallthrough 를 사용하면 이 자동으로 break가 사용되는 것을 막는 효과를 가져온다.

 

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 //이후 case까지 진행
default:
    description += " an integer."
}
print(description)
// Prints "The number 5 is a prime number, and also an integer."

 

 

이른 탈출

 

guard

 

 

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

func greet(person: [String: String]) {
    guard let name = person["name"] else { // name 키가 있으면 let name = person["name"]
        return 
    }

    print("Hello \(name)!")

    guard let location = person["location"] else { // location 키가 있으면 let location = person["location"]
        print("I hope the weather is nice near you.")
        return 
    }

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

greet(person: ["name": "John"])
// Prints "Hello John!"
// Prints "I hope the weather is nice near you."
greet(person: ["name": "Jane", "location": "Cupertino"])
// Prints "Hello Jane!"
// Prints "I hope the weather is nice in Cupertino."