Swift 공식 문서 정리 - 제어 흐름 (Control Flow)

안녕하세요. 이번에는 Swift 제어 흐름(Control Flow)에 대해 알아보겠습니다. 제어 흐름은 코드의 실행 순서를 결정하는 다양한 구문들을 포함하고 있으며, 이를 잘 활용하면 효율적이고 읽기 쉬운 코드를 작성할 수 있습니다.

📌 제어 흐름 소개

Swift는 다양한 제어 흐름 구문을 제공합니다:

• 루프: for-in, while, repeat-while
• 조건문: if, switch, guard
• 제어 변경 구문: break, continue, fallthrough
• 기타: defer, 가용성 확인 등

이러한 구문들을 통해 코드의 실행 순서를 제어하고, 조건에 따라 다른 코드를 실행하며, 반복 작업을 수행할 수 있습니다.

📌 For-In 루프

for-in 루프는 배열, 범위, 문자열 등의 컬렉션 요소를 순회할 때 사용합니다.

배열 순회하기

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

딕셔너리 순회하기

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

참고: 딕셔너리는 순서가 보장되지 않으므로 순회 결과의 순서도 정해져 있지 않습니다.

숫자 범위 순회하기

for index in 1...5 {
    print("\(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

값 무시하기

값이 필요 없을 때는 언더바(_)를 사용해 값을 무시할 수 있습니다:

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

다양한 범위 사용하기

// 반열림 범위 연산자(..<)
for tickMark in 0..<60 {
    // 0부터 59까지 60번 실행
}

// stride 함수 사용하기
for tickMark in stride(from: 0, to: 60, by: 5) {
    // 0, 5, 10, ..., 55 (5씩 증가, 60은 포함하지 않음)
}

// 닫힌 범위와 함께 stride 사용하기
for tickMark in stride(from: 3, through: 12, by: 3) {
    // 3, 6, 9, 12 (3씩 증가, 12 포함)
}

범위 연산자:

• a...b: a부터 b까지(b 포함) - 닫힌 범위
• a..<b: a부터 b-1까지(b 제외) - 반열림 범위
• stride(from:to:by:): 특정 간격으로 범위 생성(끝값 제외)
• stride(from:through:by:): 특정 간격으로 범위 생성(끝값 포함)

📌 While 루프

While

while 루프는 조건이 false가 될 때까지 코드 블록을 반복 실행합니다:

var square = 0
var diceRoll = 0

while square < 25 {
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    square += diceRoll

    if square < board.count {
        square += board[square]  // 게임판의 효과 적용
    }
}
print("Game over!")

while 루프: 조건을 먼저 확인한 후 조건이 true면 코드 블록을 실행합니다.

Repeat-While

repeat-while 루프는 먼저 코드 블록을 실행한 후 조건을 확인합니다:

var square = 0
var diceRoll = 0

repeat {
    square += board[square]  // 게임판의 효과 적용

    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }
    square += diceRoll
} while square < 25

print("Game over!")

repeat-while 루프: 다른 언어의 do-while과 유사하며, 코드 블록을 먼저 실행한 후 조건을 확인합니다. 따라서 코드 블록이 최소 한 번은 실행됩니다.

📌 조건문

If 구문

if 구문은 조건에 따라 코드를 실행합니다:

var temperatureInFahrenheit = 30
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.")
}

Swift 5.9부터는 if 표현식을 사용하여 값을 할당할 수 있습니다:

let weatherAdvice = if temperatureInCelsius <= 0 {
    "It's very cold. Consider wearing a scarf."
} else if temperatureInCelsius >= 30 {
    "It's really warm. Don't forget to wear sunscreen."
} else {
    "It's not that cold. Wear a T-shirt."
}

if 표현식: Swift 5.9에서 추가된 기능으로, 조건에 따른 값을 직접 변수나 상수에 할당할 수 있습니다.

Switch 구문

switch 구문은 값을 여러 패턴과 비교합니다:

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

Swift 5.9부터는 switch 표현식도 지원합니다:

let message = switch anotherCharacter {
case "a":
    "The first letter of the Latin alphabet"
case "z":
    "The last letter of the Latin alphabet"
default:
    "Some other character"
}

Swift의 switch 구문은 다른 언어와 달리 명시적 fallthrough가 없습니다(각 case 실행 후 자동으로 다음 case로 넘어가지 않습니다). 또한 각 case는 최소 하나의 실행 가능한 구문이 필요합니다.

다양한 패턴 매칭

1. 간격 매칭:

   swift

   let approximateCount = 62
   switch approximateCount {
   case 0:
       print("no")
   case 1..<5:
       print("a few")
   case 5..<12:
       print("several")
   case 12..<100:
       print("dozens of")
   default:
       print("many")
   }
   // "dozens of"

2. 튜플 매칭:

   swift

   let somePoint = (1, 1)
   switch somePoint {
   case (0, 0):
       print("Origin")
   case (_, 0):
       print("On the x-axis")
   case (0, _):
       print("On the y-axis")
   case (-2...2, -2...2):
       print("Inside the box")
   default:
       print("Outside the box")
   }
   // "Inside the box"

3. 값 바인딩:

   swift

   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"

4. where 절 사용:

   swift

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

5. 합성 케이스:

   let someCharacter: Character = "e"
   switch someCharacter {
   case "a", "e", "i", "o", "u":
       print("\(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":
       print("\(someCharacter) is a consonant")
   default:
       print("\(someCharacter) is not a vowel or a consonant")
   }
   // "e is a vowel"

패턴 매칭: 값을 다양한 패턴과 비교하는 방법

와일드카드 패턴(_): 어떤 값이든 매칭되는 패턴

값 바인딩: 매칭된 값을 임시 변수나 상수에 바인딩하는 방법

where 절: 패턴 매칭에 추가 조건을 지정하는 방법

합성 케이스: 여러 패턴을 하나의 case로 결합하는 방법

📌 제어 변경 구문

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"

continue: 현재 루프 반복을 중단하고 다음 반복으로 넘어갑니다.

Break

break 구문은 전체 제어 흐름 구문의 실행을 즉시 종료합니다:

// 루프에서 break
let scores = [10, 20, 30, 40, 50]
var sum = 0
for score in scores {
    if score > 30 {
        break
    }
    sum += score
}
print(sum)  // 60 (10 + 20 + 30)

// switch에서 break
let numberSymbol: Character = "三"  // 중국어로 3
var possibleIntegerValue: Int?
switch numberSymbol {
case "1", "١", "一", "๑":
    possibleIntegerValue = 1
case "2", "٢", "二", "๒":
    possibleIntegerValue = 2
case "3", "٣", "三", "๓":
    possibleIntegerValue = 3
default:
    break
}

break:

• 루프에서: 루프의 실행을 즉시 종료하고 루프 다음 코드로 이동
• switch에서: switch 구문을 즉시 종료

Fallthrough

Swift의 switch 구문은 기본적으로 각 case에서 다음 case로 자동으로 넘어가지 않지만, fallthrough를 사용하면 명시적으로 다음 case로 넘어갈 수 있습니다:

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."

fallthrough: switch 문에서 현재 case 실행 후 다음 case로 실행을 계속합니다.

📌 라벨이 있는 구문

복잡한 제어 흐름에서는 특정 루프나 조건문을 식별하기 위해 라벨을 사용할 수 있습니다:

gameLoop: while square != finalSquare {
    diceRoll += 1
    if diceRoll == 7 { diceRoll = 1 }

    switch square + diceRoll {
    case finalSquare:
        // 게임 종료
        break gameLoop
    case let newSquare where newSquare > finalSquare:
        // 유효하지 않은 이동
        continue gameLoop
    default:
        // 유효한 이동
        square += diceRoll
        square += board[square]
    }
}
print("Game over!")

라벨이 있는 구문: 구문에 식별자를 붙여 break나 continue 등의 제어 흐름 변경 시 어떤 구문에 적용할지 명시적으로 지정합니다.

📌 이른 종료 (Guard)

guard 구문은 특정 조건이 충족되지 않으면 현재 코드 블록에서 빠져나가도록 합니다:

func greet(person: [String: String]) {
    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).")
}

greet(person: ["name": "John"])
// "Hello John!"
// "I hope the weather is nice near you."

guard 구문의 장점:

1. 필요한 조건이 충족되지 않으면 일찍 함수를 종료할 수 있습니다.
2. 옵셔널 바인딩으로 해제된 값은 guard 이후 코드에서도 사용 가능합니다.

guard: 특정 조건이 충족되어야 이후 코드를 실행하며, 조건이 충족되지 않으면 else 블록을 통해 현재 범위를 빠져나갑니다.

📌 연기된 동작 (Defer)

defer 블록은 현재 범위가 종료될 때 실행될 코드를 지정합니다:

var score = 1
if score < 10 {
    defer {
        print(score)
    }
    score += 5
}
// "6" 출력

여러 defer 블록이 있는 경우 마지막에 정의된 블록부터 역순으로 실행됩니다:

if score < 10 {
    defer {
        print(score)
    }
    defer {
        print("The score is:")
    }
    score += 5
}
// "The score is:" 출력
// "6" 출력

defer: 현재 범위가 종료될 때 실행될 코드 블록을 정의합니다. 자원 해제, 파일 닫기 등 정리 작업에 유용합니다.

📌 API 가용성 확인

특정 API가 실행 중인 iOS/macOS 버전에서 사용 가능한지 확인합니다:

if #available(iOS 10, macOS 10.12, *) {
    // iOS 10 이상 또는 macOS 10.12 이상에서만 실행
} else {
    // 이전 버전에서 실행할 대체 코드
}

Swift 5.6부터는 반대로 확인할 수도 있습니다:

if #unavailable(iOS 10) {
    // iOS 10 미만에서만 실행
}

#available: 코드가 특정 플랫폼 버전 이상에서만 실행되도록 보장합니다.

#unavailable: 코드가 특정 플랫폼 버전 미만에서만 실행되도록 보장합니다.

📌 정리

Swift의 제어 흐름 구문은 코드의 실행 흐름을 효율적으로 제어할 수 있는 강력한 도구입니다. 특히 Swift만의 특징적인 요소들을 정리하자면:

• for-in 루프는 다양한 컬렉션과 범위를 쉽게 순회할 수 있게 해줍니다.
• switch 구문은 패턴 매칭이 매우 강력하며, 자동 fallthrough가 없습니다.
• guard 구문은 조건 검사와 이른 종료를 통해 코드의 가독성을 높여줍니다.
• defer 블록은 코드 실행 범위가 종료될 때 정리 작업을 보장합니다.
• API 가용성 확인은 다양한 OS 버전을 지원하는 앱 개발에 필수적입니다.

이러한 제어 흐름 요소들을 적절히 조합하면, 더 안전하고 효율적이며 읽기 쉬운 Swift 코드를 작성할 수 있습니다.