5. Functions

Alert

이 글은 Claude Code의 도움을 받아 작성되었습니다

TL;DR

• Go 함수는 파라미터 타입과 반환 타입을 반드시 명시해야 하며, 선택적 파라미터가 없음
• ... 문법으로 가변 인자를 받을 수 있고, Python의 *args에 대응
• 다중 반환값이 기본이며, result, err 패턴이 Go 에러 처리의 핵심 관용구
• 함수는 first-class citizen이라 변수에 담거나 인자로 전달 가능하고, 클로저도 지원
• defer는 자원 정리를 함수 끝까지 미루며, 후입선출(LIFO)로 실행되고 인자는 등록 시점에 평가됨
• Go는 값에 의한 호출(call by value)이라 구조체는 복사되지만, 맵·슬라이스는 내부 데이터를 공유해 수정이 반영됨

---

1. 기본 함수 선언

Go의 함수 선언은 func 키워드로 시작한다. Python과 달리 파라미터 타입과 반환 타입을 반드시 명시해야 한다.

func add(a int, b int) int {
    return a + b
}

Python이라면 이렇게 쓴다.

def add(a, b):
    return a + b

차이점을 정리하면 다음과 같다.

• 타입 명시 필수 : Go는 파라미터 타입(int)과 반환 타입(int)을 생략할 수 없다. Python의 타입 힌트(a: int)는 선택이지만 Go에서는 강제다.
• 같은 타입 축약 : 연속된 파라미터가 같은 타입이면 func add(a, b int) int처럼 마지막에 한 번만 적을 수 있다.
• 선택적 파라미터 없음 : Python은 def add(a, b=0):처럼 기본값을 줄 수 있지만, Go는 모든 파라미터가 필수다. 선택적 설정이 필요하면 구조체를 쓰는 패턴이 일반적이다.
• 중괄호 위치 : 여는 중괄호 {는 반드시 func 선언과 같은 줄에 있어야 한다. 다음 줄로 내리면 컴파일 에러가 난다.

---

2. 가변 입력 파라미터

인자 개수가 유동적일 때 ... 문법을 쓴다. Python의 *args에 대응하는 개념이다.

func addTo(base int, vals ...int) []int {
    out := make([]int, 0, len(vals))
    for _, v := range vals {
        out = append(out, base+v)
    }
    return out
}

호출할 때는 인자를 나열하거나, 슬라이스를 펼쳐서 넘길 수 있다.

addTo(3, 2, 4, 6)       // [5, 7, 9]
 
a := []int{4, 3}
addTo(3, a...)           // 슬라이스 펼치기 → [7, 6]

Python으로 같은 기능을 구현하면 이렇다.

def add_to(base, *vals):
    return [base + v for v in vals]
 
add_to(3, 2, 4, 6)      # [5, 7, 9]
 
a = [4, 3]
add_to(3, *a)            # 리스트 언패킹 → [7, 6]

**kwargs는 없다

Python의 **kwargs(키워드 가변 인자)에 대응하는 Go 문법은 없다. 이름 붙은 선택적 파라미터가 필요하면 구조체를 정의해서 넘기는 패턴을 쓴다. 이 부분은 구조체 편에서 다룬다.

---

3. 다중 반환값

Go 함수의 가장 큰 특징 중 하나다. 여러 값을 동시에 반환할 수 있고, 이를 통해 에러 처리 패턴이 만들어진다.

func divAndRemainder(num, den int) (int, int, error) {
    if den == 0 {
        return 0, 0, errors.New("cannot divide by zero")
    }
    return num / den, num % den, nil
}
 
result, remainder, err := divAndRemainder(5, 2)
// result=2, remainder=1, err=nil

Python에서 비슷한 코드를 쓰면 이렇다.

def div_and_remainder(num, den):
    if den == 0:
        raise ValueError("cannot divide by zero")
    return num // den, num % den
 
result, remainder = div_and_remainder(5, 2)
 
# 또는 튜플로 한 번에 받기
result = divmod(5, 2)   # (2, 1)

핵심적인 차이가 있다.

• 개별 변수로 받아야 함 : Python은 result = divmod(5, 2)처럼 튜플 하나로 묶어 받을 수 있지만, Go는 반환값 개수만큼 변수를 선언해야 한다.
• 안 쓰는 값은 _로 무시 : 반환값 중 필요 없는 것이 있으면 _에 할당한다. Python도 같은 관례를 쓴다.

result, _, err := divAndRemainder(5, 2)   // remainder 무시

• result, err 패턴 : Go는 예외(exception) 대신 에러를 반환값으로 돌려주는 방식을 쓴다. 마지막 반환값을 error 타입으로 두고, 호출 측에서 err != nil을 확인하는 것이 Go의 기본 에러 처리 관용구다.

result, remainder, err := divAndRemainder(5, 0)
if err != nil {
    fmt.Println(err)    // "cannot divide by zero"
    return
}

에러 처리는 별도 편에서

Go의 에러 처리(error 인터페이스, errors.New, fmt.Errorf, 래핑 등)는 내용이 많아 별도 글에서 다룬다. 여기서는 “마지막 반환값으로 에러를 돌려준다”는 패턴만 기억하면 된다.

---

4. 함수는 값이다 (first-class function)

Go에서 함수는 first-class citizen(일급 객체)이다. 어떤 값이 first-class라는 건 다음을 모두 할 수 있다는 뜻이다.

• 변수에 담을 수 있다
• 함수의 인자로 넘길 수 있다
• 함수의 반환값으로 쓸 수 있다
• 슬라이스나 맵 같은 자료구조에 넣을 수 있다

함수가 이 조건을 만족하면 “그 언어는 함수를 first-class로 취급한다”고 말하고, 이런 함수를 first-class function이라 부른다. Go와 Python 모두 여기에 해당한다. 반면 C는 함수 포인터로 비슷하게 흉내 낼 수는 있지만, 익명 함수나 클로저가 없어서 함수를 완전한 first-class로 보기는 어렵다.

헷갈리는 용어 정리

함수를 값으로 다루는 이야기에는 비슷해 보이는 용어가 여럿 나온다. 관계를 정리하면 이렇다.

용어	무엇을 가리키나
first-class function	함수를 값처럼 다룰 수 있다는 언어의 성질. 아래 개념들을 가능하게 하는 토대
function value	변수에 담거나 전달되는 값으로서의 함수. Go 공식 문서에서 쓰는 표현
higher-order function(고차 함수)	함수를 인자로 받거나 반환하는 함수
anonymous function(익명 함수)	이름 없이 즉석에서 정의한 함수. Go의 func(){...}, Python의 lambda
closure(클로저)	익명 함수가 바깥 스코프 변수를 캡처한 것

핵심은 first-class function이 “성질”이고, 나머지는 그 성질 위에서 만들어지는 활용 패턴이라는 점이다. 익명 함수와 클로저는 같이 등장할 때가 많지만 엄밀히는 다르다. 익명 함수가 바깥 변수를 붙잡지 않으면 클로저가 아니다.

둘은 서로 다른 축으로 보면 깔끔하다. 익명 함수는 “이름이 있냐 없냐”(형태)의 문제고, 클로저는 “바깥 변수를 캡처했냐”(동작)의 문제다. 그래서 이론적으로는 이름 있는 함수도 바깥 변수를 캡처하면 클로저가 될 수 있다(Python의 nonlocal이 그 예다). 다만 Go는 함수 안에서 이름 있는 함수를 선언할 수 없어서, Go의 클로저는 사실상 항상 익명 함수다.

// 변수에 함수 할당
add := func(a, b int) int { return a + b }
fmt.Println(add(3, 4))   // 7

Python이라면 lambda를 쓰거나, 일반 함수를 변수에 할당한다.

add = lambda a, b: a + b
print(add(3, 4))   # 7

함수를 파라미터로 받는 예시도 보자.

func apply(a, b int, op func(int, int) int) int {
    return op(a, b)
}
 
result := apply(3, 4, func(a, b int) int {
    return a + b
})
// result=7

def apply(a, b, op):
    return op(a, b)
 
result = apply(3, 4, lambda a, b: a + b)
# result=7

Go에서 함수 타입 시그니처(func(int, int) int)를 매번 쓰는 것이 번거로우면 type으로 별칭을 만들 수 있다.

type mathFunc func(int, int) int
 
func apply(a, b int, op mathFunc) int {
    return op(a, b)
}

위 apply는 설명용 예시지만, 함수를 파라미터로 넘기는 패턴은 표준 라이브러리에서 자주 만난다. 대표적인 것이 sort.Slice다. 정렬 기준을 함수로 받아서, “두 원소 중 어느 쪽이 앞에 와야 하는가”를 호출 측이 결정하게 한다.

type Person struct {
    Name string
    Age  int
}
 
people := []Person{
    {Name: "Alice", Age: 30},
    {Name: "Bob", Age: 25},
    {Name: "Carol", Age: 35},
}
 
// 나이 오름차순 정렬 — 비교 함수를 인자로 전달
sort.Slice(people, func(i, j int) bool {
    return people[i].Age < people[j].Age
})

Python에서 sort의 key 인자에 함수를 넘기는 것과 같은 발상이다.

people.sort(key=lambda p: p.age)

이 예시는 사실 클로저다

sort.Slice에 넘긴 익명 함수는 바깥의 people 변수를 캡처하고 있다. 즉 단순히 함수를 파라미터로 넘긴 것을 넘어, 바깥 변수를 붙잡은 클로저를 넘긴 것이다. 실무에서 함수를 인자로 넘길 때는 이렇게 클로저인 경우가 대부분이다. 클로저 자체는 바로 다음 섹션에서 다룬다.

---

5. 클로저

클로저는 함수가 자신이 선언된 바깥 스코프의 변수를 캡처해서 유지한다. Go와 Python 모두 클로저를 지원한다.

func makeCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
 
counter := makeCounter()
fmt.Println(counter())   // 1
fmt.Println(counter())   // 2
fmt.Println(counter())   // 3

Python 버전은 이렇다.

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter
 
counter = make_counter()
print(counter())   # 1
print(counter())   # 2
print(counter())   # 3

• Go는 바깥 변수를 자동으로 캡처한다. Python처럼 nonlocal 같은 키워드가 필요 없다.
• makeCounter()를 호출할 때마다 독립적인 count가 생기므로, 카운터 인스턴스끼리 상태가 섞이지 않는다.

5-1. 왜 클로저를 쓰는가 — 범위를 좁힌다

클로저의 효용이 잘 와닿지 않을 수 있다. 가장 실용적인 이유 하나는 함수의 범위를 좁히는 것이다.

Go 함수는 보통 패키지 레벨(파일 최상위)에 선언한다. 그런데 어떤 헬퍼 함수가 딱 한 함수 안에서만 쓰인다면, 굳이 패키지 레벨에 둘 이유가 없다. 예를 들어 process 안에서만 쓰는 double이 있다고 하자.

// 방법 1: 패키지 레벨에 선언 — 패키지 전체에 노출됨
func double(x int) int {
    return x * 2
}
 
func process(nums []int) []int {
    out := make([]int, 0, len(nums))
    for _, n := range nums {
        out = append(out, double(n))
    }
    return out
}

이렇게 하면 double이 같은 패키지의 다른 함수, 다른 파일에서도 전부 보인다. 실제로는 process에서만 쓰는데도 패키지 네임스페이스를 차지한다. 내부 함수로 가두면 호출 범위가 process 안으로 제한된다.

// 방법 2: process 안에 가둠 — 바깥에서는 존재조차 모름
func process(nums []int) []int {
    double := func(x int) int {
        return x * 2
    }
 
    out := make([]int, 0, len(nums))
    for _, n := range nums {
        out = append(out, double(n))
    }
    return out
}

이게 왜 이득인지는 02편에서 다룬 내용과 연결된다.

• 패키지 레벨 선언 수가 줄어든다 : Go 컴파일러는 패키지 레벨의 미사용 함수/변수를 에러로 잡아주지 않는다. 패키지 레벨에 이름이 많을수록 “이거 아직 쓰나?”를 판단하기 어려워지는데, 한 곳에서만 쓰는 헬퍼를 함수 안으로 넣으면 그만큼 패키지 레벨이 깔끔해진다.
• 안 쓰는 이름을 찾기 쉬워진다 : 함수 내부의 지역 변수나 내부 함수는 사용하지 않으면 컴파일 에러가 난다. 즉 내부로 가두면 “안 쓰는 코드”가 자동으로 드러난다.

방금 예시는 엄밀히는 클로저가 아니다

double은 바깥 변수를 캡처하지 않으므로 정확히는 익명 함수일 뿐이다(섹션 4의 용어 정리 참고). 다만 내부 함수가 바깥의 지역 변수까지 캡처하는 경우가 많아서, 실무에서는 이 패턴을 묶어서 클로저라고 부른다. 캡처까지 하면 헬퍼에 매번 인자를 넘기지 않아도 되는 이점이 추가된다.

func process(nums []int, factor int) []int {
    // factor를 캡처 — 인자로 안 넘겨도 됨
    multiply := func(x int) int { return x * factor }
    out := make([]int, 0, len(nums))
    for _, n := range nums {
        out = append(out, multiply(n))
    }
    return out
}

클로저의 실전 용도

클로저는 미들웨어, 팩토리 함수, 지연 실행 등에서 자주 쓰인다. 특히 Go의 HTTP 핸들러에서 의존성을 주입할 때 클로저 패턴이 일반적이다.

---

6. defer

defer는 함수 호출을 그 함수가 끝날 때까지 미뤄두는 키워드다. 주로 열어둔 자원(파일, 네트워크 연결, 락 등)을 잊지 않고 정리하는 데 쓴다. 정리 코드를 자원을 연 코드 바로 옆에 적어둘 수 있어서, 함수가 어떤 경로로 끝나든 정리가 보장된다.

func readFile(name string) error {
    f, err := os.Open(name)
    if err != nil {
        return err
    }
    defer f.Close()   // 함수가 끝날 때 실행됨 — 여기서 닫는 걸 잊을 일이 없다
 
    // f를 가지고 작업...
    // 중간에 return해도 f.Close()는 반드시 실행된다
 
    return nil
}

Python의 with문이나 try/finally와 목적이 같다.

# Python — with문이 블록을 벗어날 때 자동으로 close
def read_file(name):
    with open(name) as f:
        # f를 가지고 작업...
        ...
    # 블록을 벗어나면 자동으로 닫힘

차이가 있다면, Python의 with는 블록을 벗어날 때 정리되고, Go의 defer는 함수가 끝날 때 정리된다는 점이다.

defer는 클로저 전용 기능이 아니다

defer 뒤에는 아무 함수 호출이나 올 수 있다. 메서드 호출(f.Close()), 일반 함수 호출(fmt.Println("done")), 익명 함수(func(){...}())를 모두 미룰 수 있다. defer의 본질은 “이 호출을 함수 끝으로 미룬다”는 실행 시점 제어일 뿐, 클로저와는 별개의 기능이다.

defer f.Close()              // 메서드 호출 — 클로저 아님
defer fmt.Println("done")    // 일반 함수 호출 — 클로저 아님
defer func() { ... }()       // 익명 함수 — 캡처하면 클로저

책에서 “defer는 여러 클로저를 지연시킨다”고 표현하는 건 defer의 정의가 아니라 실제 쓰임을 반영한 것이다. 자원 하나 닫는 정도면 defer f.Close() 한 줄로 끝나지만, 아래 6-3·6-4에서 볼 “실행 시점의 변수 읽기”나 “명명된 반환값 수정”, recover 같은 의미 있는 정리 작업은 여러 줄을 익명 함수로 묶고 바깥 변수를 캡처하게 된다. 그게 곧 클로저다. 즉 defer가 클로저를 요구하는 게 아니라, 쓸 만한 defer가 자연스럽게 클로저 형태가 되는 것이다.

두 축을 분리해서 보면 깔끔하다. defer는 “언제 실행할지”(실행 시점 제어), 클로저는 “무엇을 들고 있을지”(변수 캡처) 를 담당한다. 서로 직교하는 개념이고, defer 예시에서 클로저가 자주 보이는 건 복잡한 정리를 익명 함수로 묶다 보니 캡처가 따라온 결과일 뿐이다.

6-1. 실행 시점 — return 이후에 실행된다

defer로 미룬 함수는 바깥 함수의 return이 반환값을 정한 뒤, 호출한 쪽으로 돌아가기 직전에 실행된다. 즉 return 문장 자체보다 늦게 실행된다.

func example() {
    fmt.Println("1. 함수 시작")
    defer fmt.Println("3. defer 실행 (마지막)")
    fmt.Println("2. 함수 본문 끝")
}
// 출력:
// 1. 함수 시작
// 2. 함수 본문 끝
// 3. defer 실행 (마지막)

6-2. 후입선출(LIFO) — 나중에 쓴 defer가 먼저 실행된다

defer는 여러 번 쓸 수 있고, 쌓아둔 순서의 역순으로 실행된다. 가장 마지막에 등록한 것이 가장 먼저 실행된다.

func main() {
    defer fmt.Println("first")
    defer fmt.Println("second")
    defer fmt.Println("third")
    fmt.Println("body")
}
// 출력:
// body
// third
// second
// first

이 순서가 자연스러운 이유가 있다. 보통 자원은 “먼저 연 것을 나중에 닫는” 게 맞기 때문이다. 예를 들어 파일을 열고 그 위에 버퍼를 씌웠다면, 버퍼를 먼저 닫고 파일을 나중에 닫아야 한다. LIFO 덕분에 연 순서대로 defer를 적기만 하면 닫는 순서가 알아서 맞춰진다.

f, _ := os.Open("data.txt")
defer f.Close()          // 나중에 실행 (2순위)
 
gz, _ := gzip.NewReader(f)
defer gz.Close()         // 먼저 실행 (1순위) — 연 순서의 역순으로 닫힘

6-3. 인자는 defer를 만나는 순간 평가된다

가장 헷갈리는 부분이다. defer에 넘긴 함수의 인자는 defer 문장을 만나는 시점에 즉시 계산되고, 실제 호출만 미뤄진다.

func main() {
    i := 0
    defer fmt.Println("defer가 본 i:", i)   // 이 시점의 i(0)가 박제됨
    i = 100
    fmt.Println("현재 i:", i)
}
// 출력:
// 현재 i: 100
// defer가 본 i: 0      ← 100이 아니라 0

i가 나중에 100으로 바뀌어도, defer는 등록 시점의 값 0을 이미 붙잡아 두었다. 인자가 아니라 클로저로 감싸면 동작이 달라진다. 클로저 안의 i는 실행 시점에 읽히기 때문이다.

func main() {
    i := 0
    defer func() {
        fmt.Println("defer가 본 i:", i)   // 실행 시점에 i를 읽음
    }()
    i = 100
}
// 출력:
// defer가 본 i: 100     ← 클로저라 최신 값

인자 평가 vs 클로저 캡처

• defer f(x) : x는 지금 평가되어 고정된다
• defer func(){ ... x ... }() : x는 나중에(실행 시점에) 읽힌다 이 차이가 defer와 클로저가 만나는 지점이다. 둘 중 무엇을 원하는지 의식하고 써야 한다.

6-4. 명명된 반환값 수정

defer에 넘긴 클로저는 함수의 명명된 반환값(named return value) 을 바꿀 수 있다. 반환값에 이름을 붙이면, return이 그 변수에 값을 넣은 뒤 defer가 실행되므로, defer 안에서 최종 반환값을 손볼 수 있다.

func double(x int) (result int) {   // 반환값에 result라는 이름을 줌
    defer func() {
        result *= 2                 // return이 정한 result를 두 배로
    }()
    result = x + 1
    return result                   // result에 x+1을 넣고 → defer가 *2
}
 
fmt.Println(double(3))   // (3+1) * 2 = 8

이 패턴은 주로 에러를 가공하거나, panic을 복구해서 에러로 바꾸는 곳(recover)에서 쓰인다. 에러 처리 편에서 더 다룬다.

6-5. 주의 — 반복문 안의 defer

defer는 함수가 끝날 때 실행되지, 반복문 한 바퀴가 끝날 때 실행되는 게 아니다. 루프 안에서 자원을 열고 defer로 닫으면, 자원이 루프 내내 쌓였다가 함수가 끝나는 순간에야 한꺼번에 닫힌다.

// 나쁜 예 — 파일 핸들이 루프 내내 안 닫히고 쌓인다
func processAll(names []string) error {
    for _, name := range names {
        f, err := os.Open(name)
        if err != nil {
            return err
        }
        defer f.Close()   // 함수가 끝날 때까지 안 닫힘 → 핸들 누수
        // ...
    }
    return nil
}

파일 수가 많으면 핸들이 고갈될 수 있다. 이럴 때는 루프 본문을 별도 함수로 분리해서, 한 바퀴가 곧 한 함수 호출이 되게 만든다. 그러면 매 반복마다 defer가 제때 실행된다.

// 좋은 예 — 한 파일 처리를 함수로 분리
func processAll(names []string) error {
    for _, name := range names {
        if err := processOne(name); err != nil {
            return err
        }
    }
    return nil
}
 
func processOne(name string) error {
    f, err := os.Open(name)
    if err != nil {
        return err
    }
    defer f.Close()   // processOne이 끝날 때마다 닫힘
    // ...
    return nil
}

defer 핵심 정리

• 자원 정리(파일/연결/락)를 연 코드 바로 옆에 적어두는 용도
• 실행 시점: 함수의 return 이후, 호출 측으로 돌아가기 직전
• 여러 개면 후입선출(LIFO)로 실행 — 연 순서대로 적으면 닫는 순서가 역순으로 맞춰짐
• 인자는 등록 시점에 평가되고, 클로저로 감싸면 실행 시점에 읽힘
• 명명된 반환값을 defer 클로저로 수정 가능
• 반복문 안에서는 함수로 분리하지 않으면 자원이 끝까지 쌓임

---

7. 값에 의한 호출 (call by value)

Go는 함수에 인자를 넘길 때 항상 값을 복사한다. 이것을 값에 의한 호출(call by value)이라고 한다. 함수는 원본이 아니라 복사본을 받으므로, 함수 안에서 파라미터를 아무리 수정해도 호출 측의 원본은 그대로다.

구조체를 넘기는 경우를 보자.

type Point struct {
    X, Y int
}
 
func modify(p Point) {
    p.X = 100   // 복사본의 필드를 바꿈
}
 
func main() {
    pt := Point{1, 2}
    modify(pt)
    fmt.Println(pt)   // {1 2} — 원본은 그대로
}

modify는 pt의 복사본을 받았기 때문에, p.X = 100은 복사본만 바꾸고 끝난다.

7-1. 객체를 참조로 넘기는 언어와의 차이

Python이나 Java는 다르게 동작한다. 객체를 넘기면 같은 객체를 가리키는 참조가 전달되므로, 함수 안에서 객체의 속성을 바꾸면 호출 측에도 반영된다.

# Python — 객체는 참조로 공유된다
class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y
 
def modify(p):
    p.x = 100   # 실제 객체의 속성을 바꿈
 
pt = Point(1, 2)
modify(pt)
print(pt.x)   # 100 — 원본이 바뀐다!

같은 코드를 Go와 Python에서 돌리면 결과가 정반대다. Python 개발자가 Go로 넘어올 때 가장 자주 헷갈리는 지점이다.

• Go: 구조체는 통째로 복사된다 → 함수 안 수정이 원본에 반영 안 됨
• Python/Java: 객체는 참조로 공유된다 → 함수 안 수정이 원본에 반영됨

7-2. 맵과 슬라이스는 예외처럼 보인다

그런데 맵과 슬라이스는 동작이 다르다. 함수에 넘겨서 내용을 바꾸면 호출 측에도 반영된다.

// 맵 — 함수 안에서 추가한 항목이 원본에 반영됨
func addEntry(m map[string]int) {
    m["new"] = 1
}
 
func main() {
    m := map[string]int{}
    addEntry(m)
    fmt.Println(m)   // map[new:1] — 바뀐다
}

// 슬라이스 — 기존 원소를 수정하면 원본에 반영됨
func zeroFirst(s []int) {
    s[0] = 0
}
 
func main() {
    nums := []int{1, 2, 3}
    zeroFirst(nums)
    fmt.Println(nums)   // [0 2 3] — 바뀐다
}

이게 call by value 원칙을 어기는 것처럼 보이지만, 사실은 일관된다. 맵과 슬라이스의 값은 데이터 자체가 아니라 내부 데이터를 가리키는 작은 헤더(포인터를 품은 구조) 다. 함수에 넘길 때 이 헤더가 복사되지만, 복사본도 결국 같은 내부 데이터를 가리킨다. 그래서 그 데이터를 수정하면 원본에도 보이는 것이다.

복사되는 건 헤더, 가리키는 데이터는 공유

슬라이스를 넘기면 (포인터, 길이, 용량) 세 값으로 된 헤더가 복사된다. 복사본의 포인터는 원본과 같은 내부 배열을 가리키므로, s[0] = 0처럼 그 배열의 원소를 건드리면 원본에도 반영된다. 맵도 같은 원리다.

7-3. 슬라이스의 함정 — append는 반영 안 될 수 있다

같은 이유로, 슬라이스에 append한 결과는 호출 측에 반영되지 않을 수 있다.

func addItem(s []int) {
    s = append(s, 99)   // 복사본 헤더의 길이만 바뀜
}
 
func main() {
    nums := []int{1, 2, 3}
    addItem(nums)
    fmt.Println(nums)   // [1 2 3] — 99가 안 보인다
}

원소를 수정하는 것(s[0] = 0)은 가리키는 배열을 직접 건드리니 반영되지만, append는 복사본 헤더의 길이·포인터만 바꾼다. 원본 헤더의 길이는 여전히 3이라서 추가된 원소가 보이지 않는다. (이 동작은 03편의 슬라이싱·저장 공간 공유 내용과 이어진다.)

7-4. 그래서 포인터가 필요하다

정리하면 Go에서 함수가 원본을 바꾸게 하려면 두 가지 길이 있다.

• 맵·슬라이스처럼 내부 데이터를 공유하는 타입은 그대로 넘겨도 내용 수정이 반영된다
• 구조체나 기본 타입의 원본을 바꾸려면 그 값의 주소(포인터)를 넘겨야 한다