swift 기초 문법 <4>

함수

특정 작업을 수행하는 코드 블록
수행하기 위해 데이터가 제공 될 수 있으며, 함수를 호출한 코드에 작업한 결과를 반환함
매개변수(parameter) -> 형식 매개변수. 함수 정의부의 값
인수(argument) -> 실 매개변수. 함수 호출시 적용 할 값
자판기(함수)에 동전(argument)을 넣어 음료수(return value)가 나온다.

함수 이름 : <함수명>(외부매개변수이름1:외부매개변수이름2:...)

코딩 : func <함수명> (매개변수 이름: 매개변수 타입, 매개변수 이름: 매개변수 타입,...) -> <반환값 타입> {함수코드}

func sayHelloWorld() -> String {  // 리턴 타입 명시
    return "hello, world"
}
print(sayHelloWorld())

func add1(x: Int, y: Int) -> Int { //외부매개변수명 생략하면 내부매개변수명이 외부 매개변수명까지 겸한다.
    return(x+y)
}
print(add1(x: 10, y: 20))  // 매개변수를 호출 할때는 이름과 세미콜론을 사용

func add2(first x: Int, second y: Int) -> Int {  // 외부매개변수 내부매개변수: 타입
    return(x+y)     // 함수 안에서는 내부 매개변수를 사용
}
print(add2(first: 10, second: 20))   // 함수 밖에서는 외부 매개변수를 사용

func add3(_ x: Int, _ y: Int) -> Int {  // 외부 매개변수 이름을 생략 (비추천)
    return(x+y)
}
print(add3(10, 20))

func add4(_ x: Int, with y: Int) -> Int {
    return(x+y)
}
print(add4(10, with: 20))  // 첫번째 외부매개변수 이름만 생략. Obj-C의 호출 방식
                          // 자주 사용한다고 함!
print(type(of:add4))  // 함수의 타입 : (Int, Int) -> Int

메소드

클래스(class), 구조체(struct), 열거형(enum) 내의 함수를 뜻함
함수를 스위프트 클래스 내에 선언하면 메소드 라고 부름

default 매개변수 정의하기

함수를 선언할 때 매개변수에 디폴트 값을 할당
argument로 전달하는 값이 없는 경우, 디폴트 매개변수 사용

func nameNumber (name: String = "홍길동", number: Int) -> String{
    return ("\(name)의 번호는 \(number)이다.")
}
var message = nameNumber(number: 20)  // name의 디폴트 값 사용
print(message)
var message2 = nameNumber(name: "hong", number: 99)  // name에 값을 할당
print(message2)

함수로부터 여러개의 결과 반환하기

여러 결과 값들을 튜플로 감싸서 반환 할 수 있음

func converter (length: Float) -> (yards: Float, centimeters: Float, meters: Float) {
    let yard = length * 0.0277778
    let centimeters = length * 2.54
    let meters = length * 0.0254
    return (yard, centimeters, meters)
}
print(converter(length: 10))
var lengthTuple = converter(length:20)
print(lengthTuple.yards)
print(lengthTuple.centimeters)
print(lengthTuple.meters)

func sss(x: Int, y: Int) -> (sum: Int, sub: Int, div: Double, multi: Int, remain: Int) {
    let sum = x + y
    let sub = x - y
    let div = Double(x) / Double(y)
    let multi = x * y
    let remain = x % y
    return (sum, sub, div, multi, remain)
}
print(sss(x:10,y:3))
print(String(format: "%.2f", sss(x:10,y:3).div))  // div 를 소수점 2자리까지
                                                // String(format)을 써서 String 타입이 됨
                                                // import Foundation 이 있어야 String 가능

가변 매개변수

여러개의 매개변수를 받는다는 것을 가리키기 위해 (...) 이용하여 함수 선언

func string1 (strings: String ...) {
    for i in strings {
        print(i)
    }
}
string1(strings: "one", "two", "three")

//임의의 개수의 정수 값의 합을 출력하는 함수
func sumNum (numbers: Int ... ) {
    var result = 0
    for i in numbers {
        result += i
    }
    print(result)
}
sumNum(numbers: 1,2,3,4)

inout 매개변수 : call by reference 구현

swift는 기본적으로 call by value
함수가 값을 반환한 후 매개변수에 일어난 변화를 유지하려면, 함수의 선언부에서 매개변수를 입출력(inout) 매개변수로 선언

var myValue = 10
func doubleValue (value: inout Int) -> Int {  // 타입명 앞에 inout 쓴다
    value += value
    return(value)
}
print(myValue)  // 초기의 myValue = 10 값 출력
print(doubleValue(value: &myValue))  // myValue를 함수의 매개변수로 사용. & 붙여서 호출
print(myValue)  //inout 때문에 리턴된 값으로 바뀜

함수를 매개변수나 리턴값으로 사용

함수를 데이터 타입처럼 처리할 수 있다.
어떤 함수에 다른 함수를 매개변수로 넘겨주거나, 함수의 리턴값으로 함수를 넘겨줄 수 있다.
스위프트 함수는 1급 객체, 1급 시민
1급 객체, 1급 시민의 조건
1. 변수에 저장 할 수 있다.
2. 매개변수로 전달 할 수 있다.
3. 리턴값으로 사용 할 수 있다.
매개변수로 함수를 받으려면, 함수의 데이터 타입을 그 함수의 데이터 타입으로 선언함.

func inchesToFeet (inches: Float) -> Float {
    return inches * 0.0833333
}
let toFeet = inchesToFeet  // 함수를 상수 or 변수에 할당 가능
var result = toFeet(10)  // 상수 or 변수 이름을 이용하여 함수 호출 가능

func inchesToYards (inches: Float) -> Float {
    return inches * 0.0277778
}
let toYards = inchesToYards

func conversion (conversionFunc: (Float) -> Float, Value: Float) { //함수를 매개변수로 호출
    let result = conversionFunc(Value)  // toYards or toFeet 함수 호출, Value는 10
    print("Result = \(result)")
}
conversion(conversionFunc: toYards, Value: 10)
// 1. conversion 함수 호출. 매개변수는 conversionFunc에 toYards, Value에 10 할당
// 2. conversion 함수 안의 상수 result 에 conversionFunc(Value) 할당
// 3. conversionFunc(Value)의 Value는 conversion의 Value값을 할당
// 4. conversionFunc에 toYards(10) 호출
// 5. toYards(10) = inchesToYards(10)
// 6. inchesToYards(10)의 값을 toYards에 리턴
// 7. toYards -> conversionFunc -> result
// 8. print함수 호출. 종료.
// 9. conversion의 타입 : ((Float) -> Float) -> ()
conversion(conversionFunc: toFeet, Value: 10)

func decideFunc (feet: Bool) -> (Float) -> Float {  //반환타입으로 함수의 타입 선언하면 함수도 반환 될 수 있다.
    if feet {
        return toFeet
    } else {
        return toYards
    }
}
decideFunc(feet: true)

클로저

클로저 표현식은 독립적인 코드 블록
이름이 없는 함수
1급 객체
클로저 표현식을 선언하고 상수에 할당한 다음, 함수를 호출

코딩 : {(매개변수이름: 매개변수 타입) -> <리턴값> in <실행코드> }

//add라는 이름의 함수
func add(x: Int, y: Int) -> Int {
    return(x+y)
}
print(add(x:1, y:2))

//이름이 없는 함수를 상수 add에 저장하여 활용
let add = {(x: Int, y: Int) -> Int in
    return(x+y)
}
print(add(2, 3))  // 상수를 함수처럼 호출!! 매개변수 이름을 안써도 됨!!

후행 클로저(trailing closure)와 축약

후행 클로저 : 클로저가 함수의 마지막 argument라면, 마지막 매개변수의 이름을 생략한 후 소괄호 외부에 클로저 구현

let mutiply = {(val1: Int, val2: Int) -> Int in
        return val1 * val2
}
let add = {(val1: Int, val2:Int) -> Int in
        return val1 + val2
}
func math (x: Int, y:Int, cal: (Int, Int) -> Int) -> Int {
    return cal(x, y)
}
var result = mutiply(10, 20)
print(result)  // mutiply의 매개변수 val1에 10, val2에 20 할당
result = add(10, 20)
print(result)
result = math(x: 10, y: 20, cal: mutiply)
print(result) //cla: mutiply 에 val1 은 10 val2는 20 할당

//클로저를 직접 매개변수에 입력
result = math(x: 10, y: 20, cal: {(val1: Int, val2: Int) -> Int in
        return val1 + val2
}

//마지막 argument cal 생략
result = math(x: 10, y: 20){(val1: Int, val2: Int) -> Int in
        return val1 + val2
} // argument cal 은 마지막이라서 생략 후 클로저 생성
  // math 함수에서 cal 의 매개변수에 x 와 y의 값을 할당
  // cal의 매개변수 val1 은 x의 값 10, val2 는 y의 값 20 을 받음
  // cal의 값 30을 리턴
print(result)  // 30

//리턴 타입 (-> Int) 생략
result = math(x: 10, y: 20, cal: {(val1: Int, val2: Int) in
        return val1 + val2  // Int + Int 이므로 리턴타입도 Int가 당연함
})
//마지막 argument + 리턴 타입 생략
result = math(x: 10, y: 20){(val1: Int, val2: Int) in
        return val1 + val2
}

// 매개변수 생략하고 단축인자(shorthand argument name) 사용
result = math(x: 10, y: 20, cal: {
        return $0 + $1  // $0=매개변수1, $1=매개변수2
})

// 리턴 타입 + 마지막 argument 생략 + 단축인자 사용
result = math(x: 10, y: 20) {
        return $0 + $1
}

// 리턴 타입 + 마지막 argument + 단축인자 사용 + return 생략
result = math(x: 10, y: 20) {
       $0 + $1  // 클로저에 리턴값이 있으면 마지막 줄을 리턴하므로 return생략
}

//1. math라는 함수를 result라는 상수에 저장
//2. math함수의 첫번째, 두번째 매개변수 (x: 10, y:20)
//3. math함수의 세번째(마지막) 매개변수 cal 에 함수타입 대입
//4. cal에 함수타입 대신 아예 클로저 함수를 적용
//5. 마지막 argument인 cal 생략 -> trailing closure
//6. 리턴타입이 명확하므로 리턴타입 생략
//7. 매개변수를 단축인자로 변경 -> shorthand argument name
//8. return 생략

출처 : https://www.youtube.com/channel/UCM8wseo6DkA-D7yGlCrcrwA