Go 함수

Go 언어에서 함수는 코드 블록을 묶어서 재사용 가능한 단위로 만들어주는 기본적인 구성 요소입니다. 함수는 일련의 문장들을 실행하는 블록이며, 특정한 동작을 수행하고 값을 반환할 수 있습니다.

함수 선언

Go에서 함수는 func 키워드를 사용하여 선언됩니다. 기본적인 함수의 형태는 다음과 같습니다:

func functionName(parameterList) returnType {
    // 함수 본문
    // return 문
}

• functionName: 함수의 이름입니다.
• parameterList: 함수에 전달되는 매개변수(parameter) 목록입니다. 매개변수가 없는 경우 비워둘 수 있습니다.
• returnType: 함수가 반환하는 값의 타입입니다. 반환할 값이 없는 경우 returnType 대신 ()를 사용합니다.
• 함수 본문: 함수가 실행할 코드 블록입니다.
• return 문: 함수가 반환할 값을 명시합니다. 반환할 값이 없는 경우 return 키워드를 생략할 수 있습니다.

함수 예제

다음은 간단한 함수 예제입니다:

package main

import "fmt"

// 두 정수를 더하는 함수
func add(x int, y int) int {
    return x + y
}

// 문자열을 출력하는 함수
func greet(name string) {
    fmt.Println("Hello, " + name + "!")
}

// 두 개의 정수와 두 개의 문자열을 반환하는 함수
func complexFunction(a int, b int) (int, int, string, string) {
    sum := a + b
    difference := a - b
    return sum, difference, "Sum", "Difference"
}

func main() {
    // 함수 호출
    result := add(3, 5)
    fmt.Println("3 + 5 =", result)

    greet("Alice")

    sum, diff, sumLabel, diffLabel := complexFunction(10, 5)
    fmt.Println(sumLabel, ":", sum)
    fmt.Println(diffLabel, ":", diff)
}

 

결과 

3 + 5 = 8
Hello, Alice!
Sum : 15
Difference : 5

함수 호출

위 예제에서 add, greet, complexFunction 등의 함수들이 선언되었고, main 함수에서 이들 함수들을 호출하고 있습니다. 함수 호출은 함수 이름을 적고 괄호 안에 매개변수들을 전달하여 수행됩니다. 예를 들어 add(3, 5)는 두 정수 3과 5를 전달하여 add 함수를 호출하고, 그 결과를 변수 result에 할당하고 있습니다.

다중 반환 값

Go 언어에서 함수는 여러 값을 반환할 수 있습니다. 위의 complexFunction 함수는 int, int, string, string 형식의 네 가지 값을 반환하고 있습니다. 함수 호출자는 이러한 값을 각각 개별 변수로 받을 수 있습니다.

익명 함수 (Anonymous Function)

Go 언어는 익명 함수를 지원하며, 함수를 정의하는 동시에 호출할 수 있습니다. 이는 함수를 변수에 할당하거나, 함수의 인수로 전달하거나, 클로저를 생성할 때 유용합니다.

 

package main

import "fmt"

func main() {
    // 익명 함수 호출
    result := func(x, y int) int {
        return x + y
    }(3, 5)

    fmt.Println("3 + 5 =", result)
}

함수의 장점

• 코드 재사용: 동일한 동작을 여러 곳에서 호출할 수 있습니다.
• 모듈화: 코드를 작은 단위로 나누어 관리할 수 있습니다.
• 가독성: 함수를 사용하면 코드의 가독성을 높일 수 있습니다.

주의사항

• Go 함수는 선언된 패키지 내에서만 호출할 수 있습니다.
• 함수 이름의 첫 글자가 대문자로 시작하면 해당 함수는 다른 패키지에서 접근 가능합니다 (public 함수).

함수는 Go 언어에서 중요한 구성 요소이며, 프로그램의 구조화된 개발과 유지보수에 필수적입니다.

 

Go 언어에서 함수는 일급 함수 (first-class function)를 지원합니다. 일급 함수란 다음의 세 가지 조건을 만족하는 함수입니다:

1. 함수를 변수에 할당할 수 있어야 합니다.
2. 함수를 다른 함수의 인자로 전달할 수 있어야 합니다.
3. 함수를 다른 함수의 반환 값으로 사용할 수 있어야 합니다.

이러한 특성들은 Go 언어에서 함수를 다른 데이터 타입과 마찬가지로 다룰 수 있게 해줍니다.

변수에 할당하기

Go에서 함수를 변수에 할당할 수 있습니다. 예를 들어:

package main

import "fmt"

func add(x, y int) int {
    return x + y
}

func main() {
    // 함수를 변수에 할당
    var sumFunc func(int, int) int
    sumFunc = add

    result := sumFunc(3, 5) // 변수를 통해 함수 호출
    fmt.Println("3 + 5 =", result)
}

위 예제에서 sumFunc 변수에 add 함수를 할당하고, 이후에는 sumFunc를 통해 함수를 호출할 수 있습니다.

함수를 인자로 전달하기

Go에서 함수는 다른 함수의 인자로 전달할 수 있습니다. 예를 들어:

package main

import "fmt"

func applyFunc(x, y int, f func(int, int) int) int {
    return f(x, y)
}

func add(x, y int) int {
    return x + y
}

func main() {
    result := applyFunc(3, 5, add)
    fmt.Println("3 + 5 =", result)
}

위 예제에서 applyFunc 함수는 세 번째 인자로 함수 f를 받고 있습니다. main 함수에서 add 함수를 applyFunc 함수의 인자로 전달하여 호출한 결과를 출력하고 있습니다.

함수를 반환 값으로 사용하기

Go에서 함수는 다른 함수의 반환 값으로 사용할 수 있습니다. 예를 들어:

package main

import "fmt"

func getAddFunc() func(int, int) int {
    return func(x, y int) int {
        return x + y
    }
}

func main() {
    addFunc := getAddFunc()
    result := addFunc(3, 5)
    fmt.Println("3 + 5 =", result)
}

위 예제에서 getAddFunc 함수는 func(int, int) int 타입의 함수를 반환합니다. main 함수에서 getAddFunc를 호출하여 반환된 함수를 addFunc 변수에 할당하고, 이후에 addFunc를 통해 함수를 호출하고 있습니다.

클로저 (Closure)

Go 언어에서 함수는 클로저를 지원합니다. 클로저란 외부 변수를 내부 함수에서 참조할 수 있는 함수입니다. 예를 들어:

package main

import "fmt"

func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}

func main() {
    addFunc := adder()

    fmt.Println(addFunc(1)) // 1
    fmt.Println(addFunc(2)) // 3
    fmt.Println(addFunc(3)) // 6
}

위 예제에서 adder 함수는 클로저를 반환합니다. 반환된 클로저는 외부 변수 sum을 참조하며, main 함수에서 addFunc를 호출할 때마다 sum에 값을 누적하고 그 결과를 반환합니다.

함수 리터럴 (Function Literal)

Go 언어에서 함수 리터럴은 이름 없이 함수를 정의할 수 있는 방법입니다. 함수 리터럴은 고루틴(Goroutine)에서 자주 사용됩니다.

package main

import "fmt"

func main() {
    func(x, y int) {
        fmt.Println("Sum:", x+y)
    }(3, 5) // 함수 리터럴을 바로 호출
}

 

위 예제에서 함수 리터럴은 이름 없이 함수를 정의하고, 바로 호출하여 결과를 출력하고 있습니다.

이와 같은 일급 함수의 특성은 Go 언어에서 함수를 더욱 유연하게 사용할 수 있도록 합니다.

 

출처 : chatGPT