[TIL] Swift 문법(함수 Functions)

함수 정의와 호출

• 함수를 선언할때는 가장 앞에 func 키워드를 붙이고 (person:String) 파라미터와 형 그리고 → String 형태로 정의함
• func example(person:String) -> String { let greeting = "Hello," + person + "!" return greeting }
• 정의한 함수에 인자 값을 넣어 호출한 예시
• print(example(person: "Bulmang")) // Print "Hello, Bulmang!"
• 위 함수에서 메세지를 결합하는 부분과 반환하는 부분을 합쳐서 더 짧게 만들 수 있음
• func shortExample(person: String) -> String { return "Hello again, " + person + "!" // 변수 선언을 안하고 반환값에 바로 입력 }

함수 파라미터와 반환 값(Function Parameters and Return Values)

<aside> 💡 Parameters : 데이터를 전달하기 위해 사용,함수를 작성할 때 입력값으로 사용될 매개변수를 선언하는데 사용,즉 함수의 선언부에서 정의됨! Swift에선 _ 를 사용하면 Parameter 이름을 생략할 수 있으며, 함수 호출시 인자만 전달이 됨 예시: shortExample(person: String) -> String 중에 person

</aside>

<aside> 💡 Argument : 함수나 메서드를 호출할 때 전달되는 값,즉 호출할 때 입력값으로 사용될 데이터 예시: forEample(num1 : 23, num2: 40). 중에 num1, num2

</aside>

파라미터가 없는 함수(Functions Without Parameters)

func noParameters() -> String {
	return "hello, world"
}
print(noParameters())

복수의 파라미터를 사용하는 함수(Functions With Multiple Parameters)

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

반환 값이 없는 함수(Functions Without Return Values)

❗정확히 말하자면 Void라는 특별한 형을 반환, Void는 () 빈 튜플

func greet(person: String) { // -> Data Type이 선언되지 않음.
	print("Hello, \\(person)!")
}
greet(person: "Bulmang")

아래의 함수 중 printWithoutCounting은 printAndCount를 호출하고 있는데 pAC는 반환값이 있기 때문에 pWC는 반환값을 사용하지 않아야 한다. 그래서 **let _ =**은 "할당하지만 사용하지 않겠다"는 의미

func printAndCount(string: String) -> Int {
    print(string)
    return string.count
}
func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string) //**let _ =**은 "할당하지만 사용하지 않겠다"는 의미
}
printAndCount(string: "hello, world")
// prints "hello, world" and returns a value of 12
printWithoutCounting(string: "hello, world")
// prints "hello, world" but does not return a valueㅁ

복수의 값을 반환하는 함수(Funcitons with Multiple Return Values)

튜플을 함수의 반환 값으로 사용 할 수 있음

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("min is \\(bounds.min) and max is \\(bounds.max)")
// Prints "min is -6 and max is 109"

옵셔널 튜플 반환형(Optional Tuple Return Types)

위의 반환 값과 달리 반환 값에 ? 물음표가 붙음.(min: Int, max: Int)?

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    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)
} 

실제 반환 값에 접근하기 위해서는 if let과 같은 옵셔널 체인을 사용하거나 강제 unwrapping을 해야함

<aside> 💡 Optional : 함수나 메서드에서 바노한값은 항상 해당 타입의 Optional값으로 래핑. Optional값은 값이 있을 수도 있고,없을 수도 있는 상황을 처리하기 위한 개념

따라서 함수나 메서드의 반환 값은 Optional값으로 래핑이 되어있으면 실제 반환 값을 사용하기 위해서는 Optional값을 해제해야 할 때 옵셔널 체인 or 강제 unwrapping을 사용

</aside>

<aside> 💡 옵셔널 체인: 옵셔널 값이 존재할 경우에만 해당 값 사용,nil일 경우 그냥 nil을 반환하는 방식 옵셔널 체인 연산자인 ?을 사용하여 값을 추출 , 반환값이 nil인 경우에도 안전하게 처리하는 방법으로 if let과 함께 옵셔널 체인을 사용하면 반환 값을 추출

</aside>

<aside> 💡 강제 unwrapping : 값이 있을 수도 있고, 없을 수도 있는 상황을 처리하기 위한 개념 !연산자를 사용하여 값을 추출, 이 방법은 반환 값이 nil인 경우 런타임 에러 발생,

</aside>

함수 인자 라벨과 파라미터 이름(Function Argument Laels and Parameter Names)

함수 호출시 적절한 파라미터 이름을 지정해 함수 내부와 함수 호출시 사용할 수 있음.

func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // 함수 내부에서 firstParameterName와 secondParameterName의 인자를 사용합니다.
}
someFunction(firstParameterName: 1, secondParameterName: 2

인자 라벨 지정(Specifying Argument Labels)

파라미터 앞에 인자 라벨을 지정해 실제 함수 내부에서 해당 인자를 식별하기 위한 이름과 함수 호출시 사용하는 이름을 다르게 사용 할 수 있음.

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

인자 생략(Omitting Argument Labels)

파라미터 앞에 _를 붙여 함수 호출시 인자 값을 생략할 수 있음

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // 함수 안에서 firstParameterName, secondParameterName
    // 인자로 입력받은 첫번째, 두번째 값을 참조합니다.
}
someFunction(1, secondParameterName: 2)

기본 파라미터 값 (Default Parameter Values)

함수의 파라미터 값에 기본값을 설정 가능, 기본값이 설정된 파라미터는 함수 호출시 생략 가능. 기본값을 사용하지 않는 파라미터를 앞에 위치 시켜야 함수를 의미잇게 사용하기 쉬움.

사용 하는 경우

1. 선택적 인자를 가진 함수를 작성할 때 : 기본 파라미터 값을 사용하면 함수 호출 시 선택적 인자를 생략가능
2. 함수의 인터페이스 유연성을 높일 때

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 함수 호출시 두번째 인자를 생략하면 함수안에서
    // parameterWithDefault값은 12가 기본 값으로 사용됩니다.
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault는 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault는 12ㅂ

집합 파라미터 (Variadic Parameters)

인자 값으로 특정 형(type)의 집합 값을 사용할 수 있습니다.

가변 인자를 사용하여 여러개의 인자를 받을 수 있다, 인자의 개수에 제약이 없으므로 유연한 함수호출 가능

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers

인-아웃 파라미터 (In-Out Parameters)

인자 값을 직접 변경하는 파라미터, 선언을 위해 파라미터 앞에 inout 이라는 키워드를 사용

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

함수 형(Function Types)

함수의 형은 파라미터 형과(parameter types) 반환 형(return type)으로 구성

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

함수 형의 사용 (Using Function Types)

아래와 같이 함수를 변수처럼 정의해서 사용 var mathFunction: (Int, Int) -> Int = addTwoInts

변수나 상수에 함수를 할당할 때 직접 함수 형을 선언하지 않아도 Swift가 형을 추론해(Type Inferred) 자동으로 함수를 할당

파라미터 형으로써의 함수 형 (Function Types as Parameter Types)

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \\(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// Prints "Result: 8"

반환 형으로써의 함수 형 (Function Types as Return Types)

함수를 반환하는 함수를 만들 수 있음.

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() 함수를 가르키고 있습니다.

중첩 함수 (Nested Functions)

함수 중에는 다른 함수안의 body 에서 동작하는 함수를 중첩 함수라고 함, 함수 밖에서 감춰져 있고 body내에서 접근이 가능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!