Go에서 함수와 다중 반환값은 어떻게 동작하나요?

Question

Accepted Answer

Go 함수는 `func`로 선언하며, 독특한 기능 하나가 **다중 반환값**입니다 — 함수가 한 번에 여러 값을 반환할 수 있습니다. 이는 특히 Go의 오류 처리를 정의하는 `(결과, 오류)` 관용구에서 광범위하게 사용됩니다.

## 기본 함수

```go
func add(a int, b int) int {     // 타입과 함께 매개변수, 그다음 반환 타입
    return a + b
}

func greet(name string) string {
    return "Hello, " + name
}
// 같은 타입 매개변수의 축약: func add(a, b int) int
```

## 다중 반환값 — 대표 기능

```go
func divide(a, b int) (int, error) {     // 결과와 오류를 모두 반환
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil    // nil 오류 = 성공
}

// 호출자는 둘 다 처리 — 어디에나 있는 Go 오류 패턴
result, err := divide(10, 2)
if err != nil {
    log.Fatal(err)       // 오류 처리
}
fmt.Println(result)
```

`(값, 오류)` 반환은 Go에서 오류 처리의 핵심 관용구입니다 — 예외 대신, 함수가 오류를 값으로 반환하고 호출자가 명시적으로 확인합니다. 이는 오류 처리를 가시적이고 조용히 무시할 수 없게 만듭니다.

## comma-ok 패턴

```go
// 많은 내장 기능이 (값, ok)를 반환 — "성공했는가?"에 대한 불리언
value, ok := myMap["key"]   // 키가 없으면 ok = false
if ok { ... }

v, ok := someInterface.(string)   // ok와 함께하는 타입 단언
```

## 명명된 반환값

```go
func split(sum int) (x, y int) {   // 명명된 반환값
    x = sum * 4 / 9
    y = sum - x
    return   // "naked return" — 명명된 값들을 반환
}
```

## 가변 인자 함수

```go
func sum(nums ...int) int {     // 임의 개수의 int를 받음
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
sum(1, 2, 3)          // 6
sum(nums...)          // slice를 인자로 펼침
```

## 함수는 일급(first-class)

```go
var op func(int, int) int = add   // 함수를 변수에 할당
func apply(fn func(int) int, x int) int { return fn(x) }  // 인자로 전달
```

## 왜 중요한가

Go의 함수는 핵심적이며, **다중 반환값**은 언어를 정의하는 기능 중 하나입니다 — 이것이 Go의 오류 처리 방식인 `(결과, 오류)` 관용구를 가능하게 합니다(예외 대신 명시적인 오류-값 확인).

사실상 모든 Go 프로그램에서 사용되는 이 패턴은 오류 처리를 가시적이고 의도적으로 만듭니다.

관련된 comma-ok 관용구(`value, ok :=`)는 곳곳에 나타납니다(map 접근, 타입 단언, channel 수신).

다중 반환, 오류 패턴, 명명된 반환, 가변 인자 함수, 일급 함수를 이해하는 것은 관용적 Go를 읽고 쓰는 데 필수적입니다 — 그리고 오류를 값으로 다루는 철학은 Go와 예외 기반 언어 사이의 가장 중요한 개념적 차이 중 하나입니다.