10장. 변수의 범위

함수를 자유롭게 쓸 수 있게 됐다. 그러자 새로운 질문이 따라온다.

함수 안에서 만든 변수는 함수 밖에서도 보이나? if 블록 안에서 만든 변수는 그 블록을 벗어나면 어떻게 되나? 같은 이름의 변수를 안과 밖에 모두 두면 어느 쪽이 우선인가?

이 답을 묶어서 변수의 범위(scope) 라고 부른다.

이 장의 목표:

변수의 범위라는 개념을 한 줄로 설명할 수 있다
패키지 / 함수 / 블록 세 단계의 범위를 구분한다
변수 가리기(shadowing) 가 무엇인지 안다
:= 가 일으키는 흔한 함정을 피한다
전역 변수를 함부로 쓰지 않는 이유를 안다

10.1 변수의 범위(scope)란

변수의 범위란 한 마디로 그 이름이 가리키는 변수가 보이는 영역 이다.

func main() {
    x := 10
    fmt.Println(x) // OK
}

fmt.Println(x) // 컴파일 에러: x 가 없음

x 는 main 함수 안에서만 존재한다. 함수가 끝나면 사라지고, 함수 바깥에서는 보이지 않는다.

Go 에서 범위는 중괄호 { } 단위로 결정된다. 중괄호로 둘러싸인 영역이 하나의 블록이 되고, 그 안에서 선언된 변수는 그 블록의 범위를 가진다.

이 단순한 규칙 위에 세 가지 단계가 쌓여 있다.

10.2 세 가지 범위

패키지 수준 (전역 변수)

함수 밖에 선언한 변수는 같은 패키지의 어떤 함수에서도 접근할 수 있다. 보통 “전역 변수” 라고 부른다.

package main

import "fmt"

var greeting = "Hello"

func sayHi() {
    fmt.Println(greeting)
}

func sayBye() {
    fmt.Println(greeting, "and bye")
}

func main() {
    sayHi()
    sayBye()
}

greeting 은 sayHi, sayBye, main 어디서나 보인다. 같은 디렉터리의 다른 .go 파일에서도 같은 패키지라면 접근할 수 있다.

다른 패키지에서도 보이게 하려면 이름의 첫 글자를 대문자로 쓴다 (Greeting). 패키지 간 export 규칙은 20장에서 자세히 다룬다.

패키지 수준 변수는 := 로 선언할 수 없다. 반드시 var 또는 const 로 적는다.

// OK
var count = 0
const limit = 100

// 컴파일 에러
count := 0

함수 수준 (지역 변수)

함수 안에서 선언한 변수는 그 함수 안에서만 살아 있다.

func work() {
    msg := "내부 메시지"
    fmt.Println(msg)
}

func main() {
    work()
    fmt.Println(msg) // 컴파일 에러: msg 가 없음
}

함수가 호출될 때마다 새로운 지역 변수들이 만들어지고, 함수가 끝나면 사라진다.

블록 수준 (`{ }` 안)

함수 안이라도 더 좁은 범위가 있다. if, for, switch 의 본문도 각자 하나의 블록이고, 그 안에서 선언한 변수는 그 블록 안에서만 보인다.

func main() {
    if x := 10; x > 0 {
        fmt.Println(x) // OK
    }
    fmt.Println(x) // 컴파일 에러
}

if 의 조건 앞에 선언한 x 는 if ~ else 블록 전체에서만 살아 있다. 바깥에서는 같은 이름의 변수가 따로 있어야 한다.

for 도 마찬가지다.

for i := 0; i < 3; i++ {
    fmt.Println(i)
}
fmt.Println(i) // 컴파일 에러

루프 변수 i 는 for 블록 안에서만 보인다.

심지어 그냥 중괄호를 열기만 해도 새 블록이 된다.

func main() {
    {
        msg := "안쪽 블록"
        fmt.Println(msg)
    }
    fmt.Println(msg) // 컴파일 에러
}

이 패턴은 자주 쓰진 않지만, “변수 범위를 일부러 좁히고 싶을 때” 쓸 수 있다.

세 단계 한눈에

범위	선언 위치	보이는 영역
패키지 수준	함수 밖	같은 패키지 전체
함수 수준	함수 본문 시작부	그 함수 안
블록 수준	`{ }` 안	그 블록 안

10.3 함수 매개변수의 범위

함수 매개변수도 결국 변수다. 범위는 함수 본문 전체 다.

func greet(name string) {
    fmt.Println("Hello,", name)
}

name 은 greet 안에서만 보인다. greet 가 끝나면 사라진다.

매개변수는 복사된다

Go 의 매개변수는 기본적으로 값 복사 다. 함수 안에서 매개변수를 바꿔도 호출한 쪽의 원본은 영향을 받지 않는다.

func bump(n int) {
    n = n + 1
    fmt.Println("안:", n)
}

func main() {
    x := 10
    bump(x)
    fmt.Println("밖:", x)
}

실행 결과:

안: 11
밖: 10

bump 안의 n 은 x 의 복사본이다. 복사본을 고친 것이지 x 자체를 고친 것은 아니다.

함수 안에서 호출자의 변수를 진짜로 바꾸고 싶다면 포인터 를 넘겨야 한다. 포인터는 14장에서 다룬다. 지금은 “매개변수는 복사된다” 만 기억해 두자.

10.4 변수 가리기 (shadowing)

같은 이름의 변수를 바깥 블록과 안쪽 블록 에 동시에 두면 어떻게 될까?

func main() {
    x := 10
    fmt.Println("바깥:", x)

    {
        x := 99
        fmt.Println("안쪽:", x)
    }

    fmt.Println("다시 바깥:", x)
}

실행 결과:

바깥: 10
안쪽: 99
다시 바깥: 10

안쪽 블록의 x 는 새로 만들어진 별개의 변수다. 바깥의 x 는 그대로 10 으로 살아 있고, 안쪽 블록이 끝나는 순간 안쪽 x 는 사라진다.

이렇게 안쪽 변수가 같은 이름의 바깥 변수를 가려 버리는 것을 변수 가리기(shadowing) 라고 부른다.

if / for 안에서 의도치 않게

문제는 의도하지 않은 shadowing 이다.

func main() {
    err := setup()
    if err != nil {
        return
    }

    if v, err := compute(); err == nil { // err 가 새로 만들어짐
        fmt.Println(v)
    }

    fmt.Println(err) // 어떤 err? 바깥의 err, 즉 setup 의 결과
}

if v, err := compute(); ... 의 err 는 조건의 짧은 명령문이라서 새로운 변수 다. 바깥의 err 와는 다른 변수다.

코드를 빨리 읽으면 마지막 err 가 compute() 의 결과처럼 보이지만, 실제로는 setup() 의 결과다. 이런 혼동이 실제로 자주 일어난다.

10.5 `:=` 의 함정

shadowing 의 단골 원인이 := 다. 원리를 짧게 정리해 둔다.

var x int 는 항상 새 변수를 만든다
x = 10 은 이미 있는 x 에 값을 넣는다
x := 10 은 그 블록 안에 같은 이름의 변수가 없으면 새로 만들고, 있으면 그대로 쓴다… 가 아니다. 이미 그 블록 안에 같은 이름이 있으면 에러 다.

핵심은 “그 블록 안에” 라는 부분이다. 바깥 블록에 같은 이름이 있어도, 새로운 안쪽 블록에서 := 를 쓰면 새 변수가 만들어진다.

func main() {
    x := 10
    {
        x := 20  // 안쪽 블록의 새 변수
        fmt.Println(x) // 20
    }
    fmt.Println(x) // 10
}

다중 반환에서의 미묘함

가장 헷갈리는 케이스가 다중 반환의 := 다.

func main() {
    n, err := strconv.Atoi("10")
    if err != nil { /* ... */ }

    n, err := strconv.Atoi("20") // ?
}

위 코드는 컴파일 에러다. n, err 둘 다 이미 같은 블록에 있기 때문이다. 이 경우엔 = 를 써야 한다.

n, err = strconv.Atoi("20")

그런데 다중 반환의 := 는 특이한 규칙이 하나 있다.

왼쪽 이름들 중에 하나라도 새 변수 면, 같은 블록 안이라도 := 가 허용된다. 이미 있는 이름은 단순 대입처럼 동작한다.

예:

n, err := strconv.Atoi("10")
m, err := strconv.Atoi("20")  // OK: m 은 새 변수, err 는 기존 변수에 대입

문제는 이 규칙이 블록이 다를 때 와 어우러지면 조용한 shadowing 을 만든다는 점이다.

err := setup()

if cond {
    n, err := compute()  // 여기서 err 는 새 변수 (블록이 다름)
    _ = n
    if err != nil {
        return
    }
}

// 여기 err 는 setup() 의 결과
// compute() 의 err 는 if 블록을 벗어나며 버려졌다

위 코드는 컴파일도 잘 되고 실행도 잘 된다. 하지만 compute() 의 에러는 처리된 적이 없다. 조용히 묻혔다.