swift - 5.문법(Functions and Closures)

▶ DEV TOOL

- Xcode 12.3

 

1. Functions and Closures

// Functions and Closures
// func를 사용해서 함수를 선언
// arguments는 타입 지정
// -> 뒤에는 리턴 타입 명시
// 함수 사용 시에는 파라미터 이름을 명시한 후 작성해야 함!!!
func greeting(name: String, greet: String) -> String{
    return "Hello \(name), \(greet)"
}
print("\(greeting(name: "Lee", greet: "Nice to meet you"))")


// 단, arguments 작성 시, _ 를 사용하면 함수 호출 시에 인자 레이블을 명시하지 않음
func greeting2(_ name : String, _ greet : String) -> String{
    return "Hello \(name), \(greet)"
}
print("\(greeting2("Lee","Nice to meet you"))")


// 함수는 여러 개의 값을 반환할 수 있음 => tuple로 여러값을 묶어서 한번에 반환할 수 있음
// ** tuple : 값을 묶어주는 것으로 구조체나 클래스 같은 거보다 간편하게 값을 묶는 용도로 사용
func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum : Int){
    var min = scores[0]
    var max = scores[0]
    var sum = 0
    
    for score in scores {
        if score > max{
            max = score
        } else if score < min {
            min = score
        }
        sum += score
    }
    return (min, max, sum)
}
let statistics = calculateStatistics(scores: [15,8,3,29,100])
print(statistics.sum) // .으로 리턴 튜플에서 원하는 값 접근 가능
print(statistics.max)
print(statistics.1) // 튜플 순서 0, 1, 2 순서로 1을 통해 max 접근 가능


// 함수는 여러 개의 가변인자(...)를 받을 수 있고, 가변인자(...)는 배열처럼 접근 가능함
// *** 가변인자 : 매번 함수에 들어가는 인수(argumetns)의 개수가 변하는 것
func sumOf(numbers : Int...) -> Int {
    var sum = 0
    print(numbers.count) // 배열처럼 사용 가능
    
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(numbers: 19, 21, 3)


// Nested funcion(중첩함수)
// 중첩함수는 바깥쪽 함수에서 변수처럼 사용이 가능함
func returnFifteen() -> Int{
    var y = 10
    
    func add() {
        y += 5
    }
    
    add()
    
    return y
}
returnFifteen()


// 함수를 리턴하고 함수를 변수로 담는 예제
// -> ((Int) -> Int)
// Int를 파라미터로 받고 Int를 리턴하는 함수 타입을 리턴
func makeIncrementer() -> ((Int) -> Int){
    func addOne(_ number : Int) -> Int{
        return 1+number
    }
    
    // addOne 이라는 함수 자체를 리턴
    return addOne
}
// 리턴되는 함수를 변수에 받아서 실행 가능
var increment = makeIncrementer() //makeIncrementer()은 addOne()함수를 리턴하고, increment 변수는 addOne()함수를 받게 됨
increment(10) // 10이 addOne함수의 인자가 되어 결과가 나온다.


// 함수를 파라미터로 받는 예제
func hasAnyMatches(_ list: [Int], condition: (Int) -> Bool) -> Bool {

    for item in list {
        print("\(item)")
        if condition(item) {
            print("func out!")
            return true
        }
    }

    return false
}

func lessThanTen(_ number: Int) -> Bool {
    return number < 10
}

var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, condition: lessThanTen) // lessThanTen 함수 자체를 파라미터로 넘겨줌


// Closure : 코드 안에서 전달되어 사용할 수 있는 로직을 가진 중괄호"{}"로 구분된 코드의 블럭
// 전달인자, 변수, 상수 등으로 저장, 전달이 가능
// 함수는 클로저의 일종으로, 이름이 있는 클로저라고 생각하면 됨
let sum: (_ A: Int, _ B: Int) -> Int = { (a: Int, b: Int) in // sum이라는 상수에 클로저를 할당
    return a + b
}
let sumResult: Int = sum(1, 2)
print(sumResult) // 3

// 클로저 예제 2
func calculate(a: Int, b: Int, method: (Int, Int) -> Int) -> Int {
    return method(a, b)
}
var result : Int
// 방법 1
result = calculate(a: 10, b: 10, method: { (left: Int, right: Int) in
    return left + right
})
print(result) // 20

// 방법 2 (후행클로저)
result = calculate(a: 10, b: 10) { (left: Int, right: Int) in
    return left + right
}
print(result) // 20

// 방법 3 단축 인자 사용
result = calculate(a: 10, b: 10, method: {
    return $0 + $1
})
print(result) // 20

// 방법 4 단축 인자 사용하는 후행클로저
result = calculate(a: 10, b: 10) {
    return $0 + $1
}
print(result) // 20

// 방법 5 단축 인자 사용하는 후행클로저, 리턴 명시 생략 가능
result = calculate(a: 10, b: 10) { $0 + $1 }
print(result) // 20