[Swift] 함수(Function) - 기본

✔️ 함수의 정의

애플 개발문서에 따르면 Swift에서 함수는 다음과 같이 정의된다.

 

[Definition]

Functions are self-contained chunks of code that perform a specific task. You give a function a name that identifies what it does, and this name is used to “call” the function to perform its task when needed.

 

함수(Functions)는 특정 작업을 수행하는 자체적으로 포함된(self-contained) 코드 덩어리(chunks) 이다. 함수가 무엇을 하는지 식별가능한 이름을 주고, 이러한 이름은 필요할때 작업을 수행하기 위해 호출(call)하여 사용된다.

- 원문 : 애플 개발 문서 Swift 4.2 Language Guide - Functions

 

Contents

1. 함수의 선언, 호출하기          1 - 1. 함수선언의 기본형태 (Defaining Functions)      1 - 2. 함수 호출 (Calling Functions)    2. 함수의 형태     2 - 1. 반환값이 없는 함수 (Functions Without Return Values)     2 - 2. 매개변수가 없는 함수 (Functions Without Parameters)     2 - 3. 반환값과 매개변수가 없는 함수 (Function Without Return Values and Parameters)     2 - 4. 매개변수가 여러개인 함수 (Function With Mulitple Parameters)     2 - 5. 반환값이 여러개인 함수 (Function With Mulitple Return Values)

🍎  함수(Function)의 선언, 호출하기

[함수의 선언(Defaining Functions)]

Swift에서 함수를 정의할 때는가장 앞에 func 키워드를 붙이고 (person: String) 파라미터와 형 그리고 -> String 형태로 반환형을 정의한다.

이 때, 함수안의 틀을 매개변수(Parameters) 타입, 틀 안에 들어가는 실제 값을 인자(Arguments)라 한다.

func <함수이름>(<매개변수1이름>: <매개변수1타입>, <매개변수2이름>: <매개변수2타입> ...) -> <반환타입> {
    <함수 구현부>
    return <반환값>
}

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

[함수 호출(Calling Functions)]

함수이름(매개변수1이름: 입력값, 매개변수2이름: 입력값 ...)

print(greet(person: "Anna", age: 20))

---

🍎  함수(Function)의 형태

2 - 1. 반환값이 없는 함수 (Functions Without Return Values)

함수는 반환값을 생략할 수 있다. 반환값이 없기 때문에 -> 과 함께 반환타입도 생략 가능하다.

func 함수이름(매개변수1이름: 매개변수1타입, 매개변수2이름: 매개변수2타입 ...) -> Void {
    /* 함수 구현부 */
}
// void 생략가능
func 함수이름(매개변수1이름: 매개변수1타입, 매개변수2이름: 매개변수2타입 ...) {
}

 

func printMyName(name: String) -> Void {
    print(name)
}

//Void 생략 가능
func printMyName(name: String){
    print(name)
}
// 호출
printYourName(name: "lee")
// >> lee

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

함수는 입력 매개변수를 생략할 수 있다. 생략하더라도 함수 이름 뒤의 소괄호()는 생략할 수 없다.

func 함수이름() -> 반환타입 {
    /* 함수 구현부 */
    return 반환값
}

 

func maximumIntegerValue() -> Int {
    return Int.max
}
// 호출
maximumIntegerValue()
// >> 9223372036854775807

 

 2 - 3. 반환값과 매개변수가 없는 함수 (Function Without Return Values and Parameters)

물론 반환값과 입력 매개변수 모두 생략할 수 있다.

func 함수이름() -> Void { // -> Void 생략 가능
    /* 함수 구현부 */
    return
}

 

// 함수 구현이 짧은 경우 가독성을 해치지 않는 범위에서 줄바꿈을 하지 않고 한 줄에 표현해도 무관하다.
func hello() -> Void { print("hello") }

// 호출
hello()
// >> hello

2 - 4. 매개변수가 여러개인 함수 (Function With Mulitple Parameters)

함수는 콤마로 구분된 여러개의 파라미터를 가질 수 있다.

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return "Hello, " + person + ". again!"
    }else{
        return "Hello, " + person + "!"
    }
}
//호출
print(greet(person: "Tim", alreadyGreeted: false))

2 - 5. 반환값이 여러개인 함수 (Function With Mulitple Return Values)

함수는 반환 타입을 튜플 값을 사용할 수 있으며 하나의 집합으로 된 다중 값을 반환한다.

func sum(_ num1: Int, _ num2: Int) -> (Int, Int, Int){
    return (num1, num2, num1+num2)
}

var sumRes = sum(20, 30)
print(sumRes)
// >> (20, 30, 50) 모든 값 출력

원하는 특정 반환값을 출력하고 싶은 경우에는 두가지 방법이 있다.

  1. index 번호로 접근하는 방법

  2. 반환값의 변수를 선언하여 변수로 접근하는 방법

func sum(_ num1: Int, _ num2: Int) -> (Int, Int, res: Int){
    return (num1, num2, num1+num2)
}

var sumRes = sum(20, 30)

// 1. index 번호로 접근
print(sumRes.0)
// >> 20

// 2. 반환값의 변수로 접근
print(sumRes2.res)
// >> 50

---

🍎 매개변수의 기본 값(default value) 설정하고 호출 시 생략하기

• 매개변수에 미리 값을 설정해놓을 수 있음
• 기본값을 갖는 매개변수는 매개변수 목록 중에 뒤쪽에 위치
• 매개변수 기본값을 가지는 매개변수는 호출 시 생략 가능
• _를 사용하여 매개변수 생략 가능

func greeting(friend: String, me: String = "lee") {
    print("Hello \(friend)! I'm \(me)")
}

//me는 기본값이 있으므로 생략 가능!
greeting(friend: "hana") // Hello hana! I'm lee
greeting(friend: "john", me: "eric") // Hello john! I'm eric

//(_)사용하여 parameter 이름 생략하기
func greeting(_ friend: String, from me: String) {
    print("Hello \(friend)! I'm \(me)")
}
greeting("Bill", from: "")	//Hello Bill! I'm

---

🍎 전달인자 레이블

• 매개변수가 어떤 역할을 할 건지 명확하게 해 줌
• 매개변수 이름 앞에 작성
• 공백으로 구분

//위 코드의 greeting과 다른 함수
//전달인자 레이블 : to, from
func greeting(to friend: String, from me: String) {
    print("Hello \(friend)! I'm \(me)")
    // 전달인자의 역할을 표현하고 싶을 때 사용
    // 함수 내부에서 전달인자(to, from) 를 사용할 때에는 매개변수 이름을 사용합니다
}

// 함수를 호출할 때에는 전달인자 레이블을 사용
greeting(to: "hana", from: "lee") // Hello hana! I'm lee

---

🍎 가변 매개변수

• 전달받을 값의 개수를 알기 어려울 때 사용할 수 있다.
• 가변 매개변수는 함수당 하나만 가질 수 있다.
• 항상 맨 뒤에 위치하며 ...으로 표현

//전달 인자 여러개 받을 수 있음(한정X)
//...으로 표현
func sayHelloToFriends(me: String, friends: String...) -> String {
    return "Hello \(friends)! I'm \(me)!"
}

print(sayHelloToFriends(me: "lee", friends: "one", "two", "three"))
// Hello ["one", "two", "three"]! I'm lee!

//인자 안 넣으려면 전달인자 아예 생략
print(sayHelloToFriends(me: "lee"))
// Hello []! I'm lee!

//매개변수 써놓고 값 안넣으면 오류 발생
//print(sayHelloToFriends(me: "lee", friends: nil))
//print(sayHelloToFriends(me: "lee", friends: ))

✔️ 가변 매개변수로 평균 구하기

func avg1(score: Int ...) -> Double{
    var total = 0
    for i in score{ //가변 인자에 넘긴 값은 적절한 타입의 배열로 만들어짐.
        total += i
    }
    return Double(total)/Double(score.count)
}
var result = avg1(score: 1, 2, 3)    //2

var a: [Int] = []
func avg2(score: Int ...) -> Double{
    a = score   // 배열에 대입 가능
    var total = 0
    for i in score{ //가변 인자에 넘긴 값은 적절한 타입의 배열로 만들어짐.
        total += i
    }
    return Double(total)/Double(score.count)
}
var result1 = avg2(score: 1, 2, 3)  //2
//가변인자 출력
print("scores : \(a)")  //scores : [1, 2, 3]
print("first score : \(a[0])") //first score : 1

---

🍎 데이터 타입으로서의 함수

• 언제나 함수는 parameter, return 값에 따른 특정 타입을 가진다.
• Swift에서는 함수 타입에 따라 변수를 정의할 수 있다.

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

var function : (Int, Int) -> Int
function = multiplyTwoInts(_:_:)
function(2, 3)

 

✔️ 매개변수 타입처럼 사용하는 함수 타입

• (Int, Int) -> (Int)와 같은 함수 타입을 다른 함수의 매개변수로 사용할 수도 있다.

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

✔️ 반환 타입처럼 사용하는 함수 타입

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
}