제어문 ( Control Flow )

안녕하세요 오늘은 Swift에서 제공하는 제어문에 관하여 적어보도록 하겠습니다 🤨

 

📚공식문서 및 링크

 

Control Flow — The Swift Programming Language (Swift 5.7)

 

---

 

Swift에서 제공하는 제어문은 

• while loop
• if guard
• switch
• for-in

For-in 문 ( For - In - Loops )

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

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

Dictionary에서 반환된 키-값 쌍으로 구성된 튜플을 순회하며 제어할 수 있습니다.

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

Dictionary형은 순서가 지정되지 않으며 반복하다고 해서 검색되는 순서가 보장되지 않습니다. 

아래의 코드를 통해 숫자 범위를 지정해 순회할 수 있습니다.

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)")
// Prints "3 to the power of 10 is 59049"

범위 연산자로 사용법입니다.

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

//0부터 59까지 총 60번 반복

stride(from:to:by:) 함수도 사용할 수 있습니다.

stride(from:to:by:) : 지정된 양만큼 단계적으로 시작 값에서 끝 값까지의 시퀀스를 반환합니다.

매개변수로는

• from start - 시퀀스에 사용할 시작 값입니다. 시퀀스에 값이 포함된 경우 첫 번쨰 값은 start입니다.
• to end - 시퀀스를 제한하는 끝 값입니다. end 결과 시퀀스의 요소가 아닙니다.
• by stride - 각 반복에서 단계별로 수행할 양입니다. 양수는 stride위쪽으로 반복됩니다. 음수는 stride아래쪽으로 반복됩니다.

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)
}
//0부터 5씩 증가하여 minutes까지 반복을합니다. minutes값은 60이므로 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

While문은 조건이 거짓일 때까지 구문을 반복합니다.

while 조건 {
	code
}

let value = true
while value {
    print("무한으로 반복됩니다")
}

var num = 0
while num < 5 {
	print( " \(num) times ")
    num += 1
}
// 0 times 
// 1 times 
// 2 times 
// 3 times 
// 4 times

 

Repeat-While 문

repeat-While문은 다른 언어의 do-while문과 유사한 while문입니다.

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

var num = 1
let value = true

repeat {
    print(num)
} while value

//repeat while문은 최소 한번은 실행되지만 조건이 true이므로 무한으로 반복됩니다.

var a = 5
var b = 10

repeat {
	a += 1
	print( " number a is increased to \(a) " )
} while a < b

// number a is increased to 6 
// number a is increased to 7 
// number a is increased to 8 
// number a is increased to 9 
// number a is increased to 10

 

조건적 구문 ( Conditional Statements )

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

 

If 문

if문은 어떠한 값이 특정 조건에 해당할 때만 선택적으로 코드를 실행합니다.

 

if만 사용했을 때

var temperatureInFahrenheit = 30
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
}
// Prints "It's very cold. Consider wearing a scarf."
//조건에 만족하므로 출력됩니다.

if else를 사용했을 때

temperatureInFahrenheit = 40
if temperatureInFahrenheit <= 32 {
    print("It's very cold. Consider wearing a scarf.")
} else {
    print("It's not that cold. Wear a t-shirt.")
}
// Prints "It's not that cold. Wear a t-shirt."
// 40<=32 조건에 만족하지 않아 else 구문을 출력합니다.

if else else-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."
//else-if 조건인 90>=86 조건에 맞아 구문을 실행합니다.

if else-if를 사용했을 때

temperatureInFahrenheit = 72
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.")
}
// 맞는 조건에 없어 아무것도 출력 되지 않습니다.

 

Switch

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

case안에는 최소 하나의 실행 구문이 반드시 있어야 합니다.

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문을 사용할 수 있습니다.

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"

위에서 말했다시피 switch구문은 암시적인 진행을 사용하지 않습니다.

switch구문이 기본적으로 모든 case를 순회하여 default를 만날 때까지 진행됩니다.

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a": 
case "A":
    print("The letter A")
default:
    print("Not the letter A")
}
//case안에는 최소 하나의 실행 구문이 반드시 있어야 합니다.
// 컴파일 에러 발생!

코드를 좀 더 효율적으로 작성할 수 있습니다. case 안에 콤마 ( , )로 구분하여 case 조건을 혼합하여 사용할 수 있습니다.

let anotherCharacter: Character = "a"
switch anotherCharacter {
case "a", "A":
    print("The letter A")
default:
    print("Not the letter A")
}
// Prints "The letter A"

 

인터벌 매칭 ( Interval Matching )

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

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).")
// 조건인 12..<100에 만족하여 naturalCount에 "dozens of" 선언됩니다.
// Prints "There are dozens of moons orbiting Saturn."

 

튜플 ( Tuple )

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"

조건인 ( -2...2 , -2...2 )에 만족하여 구문을 출력합니다.

 

Where문

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

 

혼합 케이스 ( Compound Cases )

case에 콤마 ( , )로 구분하여 여러 조건을 혼합하여 사용 가능합니다.

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")
}
// Prints "e is a vowel"

값-바인딩에서도 사용할 수 있습니다.

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

 

제어 전송 구문 ( Control Transfer Statements )

코드의 진행을 계속할지 말지를 결정하거나 실행되는 코드의 흐름을 바꾸기 위해 사용합니다.

• 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
    } else {
        puzzleOutput.append(character)
    }
}
print(puzzleOutput)
// Prints "grtmndsthnklk"

break문

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에서는 조건에 맞는 case을 실행하면 switch문은 종료됩니다. 하지만 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)
// Prints "The number 5 is a prime number, and also an integer."

※ fallthrough는 case 조건을 확인하지 않고 그냥 다음  case를 실행하게 만듭니다.

구문 레이블

반복문이나 조건문 등 특정 구문에 레이블을 붙여 기억하게 만들며 break, continue구문이 사용될 때 만든 레이블을 명시해줌으로써 원하는 구문 위치에 정확히 흐름 제어가 될 수 있도록 하는 문법입니다.

label name: while condition {
    statements
}

aLable : for i in 1..<10{
	bLable : for j in 1..<5{
    	if( j == 4 ){
        	break aLable
        }
         print(" i:\(i) j:\(j) ")
    }		
}
// i:1 j:1 
// i:1 j:2 
// i:1 j:3

 

이른 탈출 ( Early Exit )

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"])
// Prints "Hello John!"
// Prints "I hope the weather is nice near you."
// 첫번째 guard 조건에 만족하여 Prints "Hello John!"을 출력하게 되었으며 
// 두번쨰 guard 조건에 만족하지 못하여 else 구문을 출력합니다.

greet(person: ["name": "Jane", "location": "Cupertino"])
// Prints "Hello Jane!"
// Prints "I hope the weather is nice in Cupertino."
// 첫번째 guard 조건에 만족하여  Prints "Hello Jane!""을 출력하게 되었으며 
// 두번쨰 guard // Prints "I hope the weather is nice near you." 을 출력하게 됩니다.

 

이용 가능한 API 버전 확인 ( Checking API Availability )

Swift에서는 기본적으로 특정 플랫폼 ( ios , macOS, tvOS, watchOS )과 특정 버전을 확인하는 구문을 제공해줍니다. 이 구문을 활용해 특정 플랫폼과 버전을 사용하는 기기에 대한 처리를 따로 할 수 있습니다.

if #available(platform name version, ..., *) {
    statements to execute if the APIs are available
} else {
    fallback statements to execute if the APIs are unavailable
}

//실제 사용 예제
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
}

 

---

Swift에서 제공하는 제어문에 관하여 정리를 해봤습니다. 정리를 하면서 구문 레이블라는 것에 대해서 처음 알게 되어

다시 한번 내용을 공부해야 할꺼같습니다ㅋㅋ