[Swift] 함수(Functions)

정의와 호출

/*
	func 함수명 (파라미터: 데이터 타입) -> 반환타입 {
    	return
    }
*/

func person (name: String, age: Int) -> String{
    var s =  "Myname is " + name + " and my age is \(age)"
    return s
}

var s = person(name: "hyebin", age: 24)
print(s) //Myname is hyebin and my age is 24

 

함수 파라미터와 반환 값

• 파라미터가 없는 함수

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

print(helloWorld()) //hello, world

• 반환 값이 없는 함수

func helloWorld(){
	print("hello, world")  //hello, world
}

helloWorld()

• 복수의 값을 반환하는 함수

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array.min()!
    var currentMax = array.max()!
    return (currentMin, currentMax)
}
var a = [1,2,3,4,5,6,12,14]

var min = 0, max = 0
(min, max) = minMax(array: a)
print(min, max) // 1, 14

print(minMax(array: a))  //(min: 1, max: 14)

• 옵셔널 튜플 반환형
  • 반환 값에 접근하기 위해 옵셔널 체이닝 혹은 강제 unwrapping 필요

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty {return nil}
    var currentMin = array.min()!
    var currentMax = array.max()!
    return (currentMin, currentMax)
}
var a = [1,2,3,4,5,6,12,14]

if let returnValue = minMax(array: a) {
    print(returnValue.min, returnValue.max)  //1, 14
}

 

함수 인자 라벨과 파라미터 이름

• 인자 라벨 지정
  • 파라미터 앞에 인자 라벨을 지정해 실제 함수 내부에서 사용하는 이름과 호출 시 사용하는 이름을 다르게 하여 사용 

func printName(insertName name: String){
    print( "my Name is " + name + ".")  //my Name is hyebin.
}

printName(insertName: "hyebin")

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

func printName(_ name: String, _ age: Int){
    print( name, age)  //hyebin 14
}

printName("hyebin" , 14)

• 기본 파라미터 값
  • 함수의 파라미터에 기본 값을 설정 
  • 기본값이 설정된 파라미터는 함수 호출 시 생략 가능

func printName(name: String, age: Int = 24){
    print( name, age)  //hyebin 24
}

printName(name: "hyebin")  //hyebin 24
printName(name: "yyy", age: 90)  //yyy 90

• 가변 파라미터
  • 파라미터 데이터 타입 뒤에 ... 키워드 사용
  • 가변 파라미터 뒤에 있는 파라미터는 인자 생략 불가
  • 기본값을 가질 수 없으며, 하나의 파라미터에서만 사용 가능

func avg(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
print(avg(1, 2, 3, 4, 5))  // 3.0
print(avg(3, 8.25, 18.75)) //10.0

• 인-아웃 파라미터
  • 함수에서 직접 파라미터 값에 접근할 수 있도록 하는 파라미터
  • 함수의 인자에 변수를 넣을 때 & 키워드 사용

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 is now \(someInt), and anotherInt is now \(anotherInt)")
// someInt is now 107, and anotherInt is now 3

함수 타입

• 모든 함수는 파라미터 형과(parameter types) 반환 형(return type)으로 구성된 특정한 함수 타입을 가짐
• 변수 형으로써의 함수형
  • 변수나 상수에 함수를 할당할 때 함수 형을 선언하지 않아도 타입 추론해 자동으로 함수 할당 가능

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

var mathFunction: (Int, Int) -> Int = addTwoInts
//var mathFunction = addTwoInts

print(mathFunction(2,3)) //5

• 파라미터 형으로써의 함수형 

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

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5) //"Result: 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)

while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")