Swift 공식 문서 정리 - 함수 (Functions)

안녕하세요. 오늘은 함수(Functions)에 대해 알아보겠습니다. 함수는 특정 작업을 수행하는 코드 블록으로, 코드의 재사용성과 가독성을 높이는 데 매우 중요합니다.

📌 함수 정의와 호출

기본 함수 정의

Swift에서 함수는 func 키워드를 사용하여 정의합니다:

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

여기서:

• func: 함수를 정의하는 키워드
• greet(person:): 함수 이름과 파라미터 레이블
• -> String: 반환 타입
• return: 함수가 값을 반환하는 키워드

함수 호출

함수는 이름과 적절한 인수(arguments)를 사용하여 호출합니다:

print(greet(person: "Anna"))
// "Hello, Anna!" 출력

함수(Function): 특정 작업을 수행하는 독립적인 코드 블록

파라미터(Parameter): 함수 정의 시 사용되는 입력 값의 이름

인수(Argument): 함수 호출 시 전달하는 실제 값

📌 함수 파라미터와 반환값

Swift 함수는 파라미터와 반환값의 사용이 매우 유연합니다.

파라미터 없는 함수

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())  // "hello, world" 출력

여러 파라미터를 가진 함수

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person: person)
    } else {
        return greet(person: person)
    }
}
print(greet(person: "Tim", alreadyGreeted: true))

반환값 없는 함수

func greet(person: String) {
    print("Hello, \(person)!")
}
greet(person: "Dave")  // "Hello, Dave!" 출력

void 반환 타입: 함수가 값을 반환하지 않을 때 사용됩니다(Swift에서는 () 또는 Void로 표현).

여러 값을 반환하는 함수

튜플을 사용하여 여러 값을 함께 반환할 수 있습니다:

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("최소값은 \(bounds.min), 최대값은 \(bounds.max)")
// "최소값은 -6, 최대값은 109" 출력

튜플(Tuple): 여러 값을 하나의 복합 값으로 그룹화하는 방법

옵셔널 튜플 반환 타입

전체 튜플이 nil일 수 있는 경우, 옵셔널 튜플 반환 타입을 사용할 수 있습니다:

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    // ... 구현 내용 생략 ...
    return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("최소값은 \(bounds.min), 최대값은 \(bounds.max)")
}

옵셔널 튜플: 전체 튜플이 nil일 수 있음을 나타내는 타입 ((Type1, Type2)?)

암시적 반환을 가진 함수

함수 본문이 단일 표현식인 경우, return 키워드를 생략할 수 있습니다:

func greeting(for person: String) -> String {
    "Hello, " + person + "!"
}

암시적 반환(Implicit Return): 단일 표현식으로 구성된 함수에서 return 키워드를 생략할 수 있는 기능

📌 함수 인수 레이블과 파라미터 이름

Swift 함수는 인수 레이블(argument label)과 파라미터 이름(parameter name)을 모두 가질 수 있습니다.

인수 레이블과 파라미터 이름

func someFunction(argumentLabel parameterName: Int) {
    // 함수 내에서는 parameterName으로 접근
}
// 호출 시에는 argumentLabel 사용
someFunction(argumentLabel: 1)

인수 레이블 지정하기

func greet(person: String, from hometown: String) -> String {
    return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// "Hello Bill! Glad you could visit from Cupertino." 출력

인수 레이블(Argument Label): 함수 호출 시 사용되는 이름

파라미터 이름(Parameter Name): 함수 내부에서 사용되는 이름

인자 레이블 생략하기

언더바(_)를 사용하여 인수 레이블을 생략할 수 있습니다:

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // 함수 구현
}
someFunction(1, secondParameterName: 2)

📌 파라미터 기본값

파라미터에 기본값을 지정할 수 있어 호출 시 해당 인수를 생략할 수 있습니다:

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 함수 구현
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6)  // parameterWithDefault는 6
someFunction(parameterWithoutDefault: 4)  // parameterWithDefault는 12 (기본값 사용)

기본 파라미터 값(Default Parameter Value): 인수가 제공되지 않을 때 사용되는 기본값

📌 가변 파라미터

가변 파라미터(variadic parameter)는 0개 이상의 특정 타입 값을 허용합니다:

func arithmeticMean(_ numbers: Double...) -> Double {
    var total = 0.0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}

arithmeticMean(1, 2, 3, 4, 5)  // 3.0 반환
arithmeticMean(3, 8.25, 18.75)  // 10.0 반환

가변 파라미터(Variadic Parameter): 함수 호출 시 여러 개의 인수를 받을 수 있는 파라미터로, 타입 뒤에 ...을 붙여 표시합니다.

📌 In-Out 파라미터

함수가 파라미터 값을 수정하고 그 변경사항을 함수 호출이 끝난 후에도 유지하고 싶을 때 in-out 파라미터를 사용합니다:

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt는 이제 \(someInt), anotherInt는 이제 \(anotherInt)")
// "someInt는 이제 107, anotherInt는 이제 3" 출력

in-out 파라미터: 함수 내에서 수정되고 함수 종료 후에도 수정된 값이 유지되는 파라미터

&기호: in-out 파라미터에 인수를 전달할 때 변수 앞에 붙이는 기호

📌 함수 타입

Swift에서 함수는 자체적인 타입을 가지고 있어 변수에 할당하거나 다른 함수의 파라미터로 전달할 수 있습니다.

함수 타입 사용하기

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}

func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

var mathFunction: (Int, Int) -> Int = addTwoInts
print("결과: \(mathFunction(2, 3))")  // "결과: 5" 출력

mathFunction = multiplyTwoInts
print("결과: \(mathFunction(2, 3))")  // "결과: 6" 출력

함수 타입(Function Type): 함수의 파라미터 타입과 반환 타입을 포함하는 타입 (예: (Int, Int) -> Int)

파라미터 타입으로 함수 타입

함수를 다른 함수의 파라미터로 전달할 수 있습니다:

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("결과: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)  // "결과: 8" 출력

반환 타입으로 함수 타입

함수가 다른 함수를 반환할 수도 있습니다:

func stepForward(_ input: Int) -> Int {
    return input + 1
}

func stepBackward(_ input: Int) -> Int {
    return input - 1
}

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero는 이제 stepBackward() 함수를 참조

while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3... 2... 1... zero! 출력

📌 중첩 함수

Swift에서는 함수 내부에 다른 함수를 정의할 수 있습니다:

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    // 중첩 함수 정의
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }

    return backward ? stepBackward : stepForward
}

var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero는 이제 중첩된 stepForward() 함수를 참조

while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4... -3... -2... -1... zero! 출력

중첩 함수(Nested Function): 다른 함수 내부에 정의된 함수로, 기본적으로 외부에서 접근할 수 없지만 포함하는 함수에 의해 반환될 수 있습니다.

📌 정리

Swift의 함수는 매우 유연하고 강력한 기능을 제공합니다:

1. 가독성 높은 함수 호출: 인수 레이블을 통해 함수 호출 시 각 인수의 용도를 명확히 할 수 있습니다.
2. 유연한 파라미터 옵션: 기본값, 가변 파라미터, in-out 파라미터 등 다양한 파라미터 옵션을 제공합니다.
3. 일급 시민으로서의 함수: 함수를 변수에 할당하거나, 파라미터로 전달하거나, 반환값으로 사용할 수 있습니다.
4. 중첩 함수: 함수 내부에 다른 함수를 정의하여 코드의 캡슐화와 재사용성을 높일 수 있습니다.

이러한 기능들을 적절히 활용하면 더 읽기 쉽고 유지보수가 용이한 코드를 작성할 수 있습니다. 특히 함수 타입과 중첩 함수는 Swift의 함수형 프로그래밍 특성을 잘 보여주는 기능입니다.