9. Functions

Functions

특정 기능을 실행하는 코드 조각, 불필요한 코드의 반복을 줄임

Calling Functions

함수를 호출하는 문법

functionName(parameters)

Defining Functions 

사용자가 직접 만든 함수

func name(parameters) -> ReturnType {
    statements
}

Return Values

리턴 값이 있는 함수, 함수에서 리턴을 선언했다면 리턴 문을 통해 반드시 값을 리턴, 함수가 리턴한 값은 함수를 호출하는 부분으로 전달, 함수 호출식이 표현식이고 함수가 리턴한 값은 표현식의 결과, 함수의 return 형이 선언되어있다면 return 키워드 다음에 표현식을 평가한 후 그 결과를 return 함

func name(parameters) -> ReturnType {
    statements
    return expression
}

Parameters

파라미터를 통해 함수로 값을 전달할 수 있음, Parameter는 임시 상수, 파라미터의 스코프는 함수 바디로 제한

func name(name : type, name : Type) -> ReturnType { // FomerParameter
    statements
}
// Calling Functions
functionName(paramName : expr) // Actual Parameter(Argument, 인자)

Parameters Default Value

파라미터에 기본값 설정, 함수 호출 시 파라미터 생략가능, 파라미터를 사용하지 않을 때 기본값을 사용

(name : Type = value)

func sayHello(to : String = "Stranger") {
    print("Hello, ＼(to)")
}

sayHello(to : "Swift") // Hello, Swift
sayHello() // Hello, Stranger

Arugument Label

함수를 호출하며 Argument를 전달할 때 사용

(name : Type)
//parameterName
//Argument Label

(label name : Type)
//Argument Label
//parameter Name


func sayHello(name : String) { // Parameter Name
    print("Hello, ＼(name)")
}
sayHello(name : "Swift") // Argument Label


func sayHello (to name : String) {

    print("Hello, ＼(name)") //Parameter Name
}

sayHello(to : "Swift") // Argument Label

func sayHello(_ name : String) { // Wildcard Pattern
    print("Hello, ＼(name)")
}

sayHello("Swift")

Variadic Parameters

일반 파라미터는 전달 가능한 Arugument가 하나로 고정되지만 가변 파라미터에는 하나 이상의 Arugument를 전달 가능, Arugument는 배열 형태로 전달, Parameter 기본 값 설정 불가능

(name : Type...)

func printSum(of nums : Int...) {
    var sum = 0
    for num in nums {
       sum += num
   	}
    print(sum)
}

printSum(of : 1, 2, 3)
printSum(of : 1, 2, 3, 4, 5)

In - Out Parameters

In - Out 파라미터로 전달 할 경우 함수 내부에서 값 변경 가능 메모리 공간을 가지고 있는 변수를 전달해야 함, 리터럴 값을 전달할 경우 오류 발생 (상수, 리터럴, 가변 파라미 퍼, 파라미터 기본 값 불가능)

(name : inout Type)
functionName(argLabel : &expr)

var num1 = 12
var num2 = 34

func swapNumber(_ a : inout Int, with b : inout Int) {
    let tmp = a
    a = b
    b = tmp
}

swapNumber(&num1, with : &num2)

Function Notation

함수표기법, 레퍼런스, 개발 서적에서 함수를 언급할 때 사용, 어떤 함수인지 유추 가능

functionName(lanel:)
functionName(lanel:lanel:)
functionName

Function Types

(parameterTypes) -> ReturnType

First - class Citizen

함수의 First - class Citizen속성을 갖고 있음

 

1. 변수나 상수에 저장 가능

2. Parameter에 전달 가능

3. 함수에서 Return 가능

(), void

() -> 비어있는 튜플,  파라미터가 없다, 리턴형이 없다

void -> return 형이 없다는 것을 나타내는 특별한 키워드, void = 빈 괄호 

func sayHello () {
    print("Hello, Swift")
}
let f1 = sayHello
f1() // Hello, Swift


func printHello(with name : String) {
    print("hello, ＼(name)")
}
let f2 : (String) -> () = printHello(with:)
let f3 =  printHello(with:)
f3("World") // hello, World


func add(a : Int, b : Int) -> Int {
    return a + b
}
var f4 : (Int, Int) -> Int = add(a:b:)
f4(1, 2) // 3


func add (_ a : Int, with b : Int -> Int {
    return a + b
}
f4 = add(_:with:)


func swapNumbers(_ a : inout Int, _ b : inout Int) {
}
let f5 = swapNumbers(_:_:)
f5 


func sum(of numbers : Int...) {
}
let f6 = sum(of:)
f6

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

func subtract(_ a : Int, _ b : Int -> Int {
    return a - b
}

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

func divide(_ a : Int, _ b : Int -> Int {
    return a / b
}

typealias ArithmeticFunction = (Int, Int) -> Int

func selectFuncion(from op : String) -> ArithmeticFunction? {
    switch op {
    case "+":
        return add(_:_:)
    case "*":
        return multiply(_:_:)
    case "-":
        return subtract(_:_:)
    case "/":
        return divide(_:_:)
    default:
        return nil
}

let af = selectFuncion(from: "+")
af?(1, 2) //3

selectFunction(from "*")?(12, 34) //408

Nested Functions

함수안에 포함되어있는 함수

func outer() -> () -> () {
    func inner() {
        print("inner")
    }
    print("outer")
    return inner
}

let f = outer()
f()

 inner 함수가 정상적으로 호출되도록 outer 함수를 호출한 스코프로 확장된 것 물론 스코프가 확장되었다 해서 직접 호출할 수 있는 것은 아님, 리턴된 함수를 통해서 간접적으로 호출할 수 있도록 스코프를 확장시키는 것