Go 변수와 상수: 메모리 모델부터 iota까지 심층 분석

2025-11-24

프로그래밍의 본질은 결국 데이터(State)를 어떻게 관리하고 변경하느냐에 달려 있습니다.
Go 언어에서 변수(Variable)와 상수(Constant)는 이 데이터를 담는 가장 기본적인 그릇이지만,
그 내부에는 Go 팀이 의도한 안전성(Safety)과 가독성(Readability)의 철학이 깊게 배어 있습니다.

이 글에서는 단순히 변수를 선언하는 문법을 넘어, Go 언어가 변수를 메모리에 할당하는 방식, Zero Value가 가지는 보안적 의미, 실무에서 자주 발생하는 변수 섀도잉(Variable Shadowing) 버그, 그리고 Go만의 독특한 상수 시스템인 Untyped Constant와 iota 패턴까지 깊이 있게 파헤쳐 봅니다.

1. Go 변수 선언의 철학: “문맥은 뒤에서 앞으로 읽힌다”

Go 언어의 변수 선언 문법은 C나 Java와 같은 언어와는 다소 다릅니다.

// C 언어 스타일
int x;

// Go 언어 스타일
var x int

왜 Go 언어는 타입을 변수명 뒤에 두었을까요? 이는 코드를 읽는 사람의 인지 과정을 고려한 설계입니다.

var: “자, 이제 변수를 선언할 거야.” (선언의 시작)
x: “그 변수의 이름은 x야.” (주체)
int: “그리고 그 x는 정수 형태를 띄고 있어.” (속성)

이 순서는 영문법의 어순과 유사하며, 함수형 프로그래밍에서 타입을 명시하는 방식과도 닮아 있습니다. 특히 복잡한 함수 포인터나 배열 포인터를 선언할 때, C언어의 문법은 난해해지기 쉽지만 Go의 문법은 왼쪽에서 오른쪽으로 읽어 내려가면 명확하게 해석됩니다.

1-1. `var` 키워드와 패키지 레벨 스코프

var 키워드는 주로 패키지 레벨(함수 밖)에서 변수를 선언할 때 사용됩니다. Go 언어에서 전역 변수(Global Variable)처럼 보이는 이 패키지 레벨 변수들은, 해당 패키지 내의 모든 파일에서 접근 가능하며, 프로그램이 시작될 때 데이터 영역(Data Segment)에 할당됩니다.

package main

// 패키지 레벨 변수 (모든 함수에서 접근 가능)
var GlobalConfig string = "Production"

func main() {
    // ...
}

🛠️ 실무 Best Practice

실무에서는 패키지 레벨 변수 사용을 최소화해야 합니다. 전역 상태(Global State)는 동시성(Concurrency) 환경에서 Race Condition을 유발하는 주범이기 때문입니다. 꼭 필요한 경우라면 sync.Mutex 등을 통해 보호하거나, 가급적 const를 사용하는 것이 좋습니다.

2. Zero Value: Go의 안전장치

C언어에서 변수를 선언하고 초기화하지 않으면, 그 변수에는 메모리에 남아있던 쓰레기 값(Garbage Value)이 들어갑니다. 이는 예기치 않은 버그나 보안 취약점의 원인이 됩니다.

하지만 Go 언어는 “모든 변수는 선언과 동시에 초기화되어야 한다”는 원칙을 가집니다. 사용자가 값을 지정하지 않으면, Go 컴파일러는 해당 타입을 Zero Value(기본값)로 강제 초기화합니다.

2-1. 타입별 Zero Value 목록

타입(Type)	Zero Value	메모리 관점의 의미
Numeric (`int`, `float`, etc.)	`0`	비트가 모두 0으로 설정됨
Boolean (`bool`)	`false`	0으로 표현됨
String (`string`)	`""` (빈 문자열)	길이는 0, 포인터는 nil이 아닌 빈 배열을 가리킴
Reference (`*T`, `slice`, `map`, `chan`, `func`)	`nil`	아무런 메모리 주소도 가리키지 않음 (Null Pointer)

2-2. Zero Value의 실무적 활용

Go의 Zero Value는 코드를 간결하게 만듭니다. 예를 들어, 카운트 변수를 0으로 초기화할 필요가 없습니다.

// 굳이 var count int = 0 이라고 쓸 필요가 없습니다.
var count int
count++ // 0에서 시작하므로 안전하게 1이 됨

특히 sync.Mutex와 같은 구조체는 Zero Value 자체가 “잠기지 않은 상태(Unlocked)“를 의미하도록 설계되어 있어, 별도의 생성자 없이 바로 사용할 수 있습니다. 이를 “Make the zero value useful”이라는 Go의 격언으로 부릅니다.

3. 짧은 변수 선언 (Short Variable Declaration) `:=`

함수 내부(Local Scope)에서는 var 키워드 대신 := 연산자를 사용하여 변수를 선언하고 초기화할 수 있습니다. 이를 타입 추론(Type Inference)이라고 합니다.

func main() {
    // 컴파일러가 우변(10)을 보고 i를 int로 추론합니다.
    i := 10

    // 컴파일러가 우변("Hello")를 보고 s를 string으로 추론합니다.
    s := "Hello"
}

3-1. `:=` 사용 시 주의사항 및 제약

함수 내부 전용: 함수 밖에서는 사용할 수 없습니다.
중복 선언의 예외: 이미 선언된 변수라도, 새로운 변수와 함께라면 :=를 사용하여 재대입이 가능합니다. 이는 에러 처리 패턴에서 자주 보입니다.

f, err := os.Open("file1") // f와 err 모두 새로 선언
// ...
d, err := os.Open("file2") // d는 새로 선언, err는 기존 변수에 재대입 (값 변경)

3-2. ☠️ 치명적인 함정: 변수 섀도잉 (Variable Shadowing)

Go 개발자들이 가장 많이 겪는 버그 중 하나가 바로 섀도잉입니다. 내부 블록(if, for 등)에서 선언한 변수가 외부 블록의 변수와 이름이 같을 경우, 외부 변수를 가려버리는 현상입니다.

func main() {
    x := 10

    if true {
        x := 20 // ⚠️ 주의! 바깥의 x를 덮어쓰는 게 아니라, 새로운 내부 변수 x를 선언함
        fmt.Println(x) // 출력: 20
    }

    fmt.Println(x) // 출력: 10 (바깥의 x는 변경되지 않음!)
}

🛠️ 디버깅 팁: 위 코드가 의도한 것이라면 상관없지만, 실수로 :=를 사용하여 바깥 변수의 값을 바꾸지 못하는 경우가 빈번합니다. 값을 변경하려면 = 연산자를 사용해야 합니다.

4. Go의 엄격한 타입 시스템 (Type System)

Go는 강타입(Strongly Typed) 언어이자 정적 타입(Statically Typed) 언어입니다. 이는 자바스크립트나 파이썬처럼 런타임에 타입이 변하거나 암묵적으로 변환되는 것을 허용하지 않는다는 뜻입니다.

4-1. 암묵적 형변환 금지

C언어에서는 int를 float에 대입하면 자동으로 변환되지만, Go는 이를 허용하지 않습니다. 서로 다른 타입 간의 연산이나 대입은 반드시 명시적 형변환(Type Conversion)이 필요합니다.

var a int = 10
var b int32 = 20

// a = b // ❌ 컴파일 에러: cannot use b (type int32) as type int in assignment
a = int(b) // ✅ 명시적 변환 필요

이러한 엄격함은 귀찮게 느껴질 수 있지만, 오버플로우(Overflow)나 데이터 손실 문제를 개발자가 명확히 인지하게 함으로써 대규모 시스템의 안정성을 보장합니다.

4-2. 타입 별칭 (Type Alias)과 기본 타입

실무에서는 가독성을 위해 기본 타입에 별칭을 붙여 사용하는 경우가 많습니다.

type UserID int64 // int64를 기반으로 하는 새로운 타입 UserID 정의

var id UserID = 12345
var rawId int64 = 12345

// if id == rawId { ... } // ❌ 컴파일 에러: 서로 다른 타입으로 취급됨

UserID와 int64는 근본적으로 같은 메모리 구조를 가지지만, Go 컴파일러는 이를 완전히 다른 타입으로 취급합니다. 이를 통해 우연히 Money 타입과 Age 타입을 더하는 것과 같은 논리적 오류를 컴파일 단계에서 차단할 수 있습니다.

5. 상수(Constant): 불변의 가치

상수는 프로그램이 실행되는 동안 절대로 변하지 않는 값을 의미합니다. Go의 상수는 const 키워드로 선언하며, 컴파일 타임에 값이 결정됩니다.

5-1. Untyped Constant (타입 없는 상수)의 마법

Go 상수의 가장 큰 특징은 타입을 명시하지 않아도 된다는 점입니다. 이를 Untyped Constant라고 부르며, 이들은 마치 수학적 숫자처럼 동작합니다.

const PI = 3.141592 // 타입을 명시하지 않음 (Untyped Float)

func main() {
    var f32 float32 = PI // 자동으로 float32로 변환되어 대입
    var f64 float64 = PI // 자동으로 float64로 변환되어 대입
}

만약 const PI float64 = 3.14라고 타입을 박아버렸다면, f32에 대입할 때 강제 형변환 float32(PI)를 해야 했을 것입니다. Untyped Constant는 이러한 불편함을 없애고 유연성을 제공합니다.

5-2. `iota`: 열거형(Enum) 패턴의 완성

Go에는 enum 키워드가 없지만, 대신 iota라는 상수 생성기를 제공합니다. iota는 const 블록 내에서 0부터 시작하여 1씩 자동으로 증가합니다.

type Status int

const (
    StatusPending Status = iota // 0
    StatusActive                // 1
    StatusSuspended             // 2
    StatusDeleted               // 3
)

이 패턴은 상태 코드, 에러 코드, 설정 옵션 등을 정의할 때 실무에서 필수적으로 사용됩니다.

💡 고급 팁: 비트 플래그와 iota

iota와 비트 연산자 <<를 결합하면 효율적인 권한 관리 시스템(비트 마스크)을 만들 수 있습니다.
const (
    PermRead  = 1 << iota // 1 (001)
    PermWrite             // 2 (010)
    PermExec              // 4 (100)
)

6. 변수의 생명주기와 메모리 (Stack vs Heap)

Go는 가비지 컬렉터(GC)를 가진 언어지만, C/C++처럼 스택(Stack)과 힙(Heap) 메모리를 구분하여 사용합니다.

스택(Stack): 함수 내의 지역 변수가 저장됩니다. 함수가 종료되면 즉시 사라지며 속도가 매우 빠릅니다.
힙(Heap): 프로그램 실행 도중 동적으로 할당되는 메모리입니다. GC가 관리하며 스택보다 느립니다.

“변수가 스택에 할당될까, 힙에 할당될까?”

Go 컴파일러는 탈출 분석(Escape Analysis)이라는 과정을 통해 이를 결정합니다. 만약 함수 내부에서 만든 변수의 주소(포인터)를 함수 외부로 반환한다면, 이 변수는 함수가 끝나도 살아있어야 하므로 힙(Heap)으로 탈출(Escape)합니다. 그렇지 않다면 스택(Stack)에 머무릅니다.

이러한 메커니즘 덕분에 Go 개발자는 메모리 할당 위치를 직접 고민하지 않아도 되지만, 고성능 서버를 개발한다면 “불필요한 힙 할당”을 줄이는 것이 최적화의 핵심이 됩니다.

7. Go 언어 네이밍 규칙: 대소문자의 비밀

마지막으로 Go 변수와 상수의 이름에는 언어 레벨에서 강제하는 접근 제어(Visibility) 규칙이 있습니다. Java의 public, private 키워드 대신 Go는 첫 글자의 대소문자를 사용합니다.

대문자로 시작 (e.g., Method, Version): Public(Exported). 다른 패키지에서 이 변수나 상수에 접근할 수 있습니다.
소문자로 시작 (e.g., count, userMap): Private(Unexported). 오직 해당 패키지 내부에서만 볼 수 있습니다.

package config

// 외부에서 config.MaxConnections로 접근 가능
const MaxConnections = 100

// 외부에서 접근 불가 (패키지 내부용)
var secretKey = "xyz-123"

이 규칙은 코드를 읽을 때 “이 변수가 외부 API인지 내부 구현 세부 사항인지”를 직관적으로 파악하게 해줍니다.

마치며: 데이터는 흐름이다

이번 글에서는 Go 언어의 변수와 상수를 단순한 문법적 요소가 아닌, 메모리 안전성, 타입 엄격성, 그리고 실무적 활용 패턴의 관점에서 살펴보았습니다.

요약하자면:

가독성: var 이름 타입 순서는 사람의 인지 구조를 따른다.
안전성: Zero Value는 초기화되지 않은 메모리 버그를 방지한다.
편의성: :=는 간결함을 주지만 섀도잉(Shadowing) 버그를 주의해야 한다.
엄격함: 암묵적 형변환은 없으며, 타입 시스템은 견고하다.
유연함: iota와 Untyped Constant는 강력한 표현력을 제공한다.

변수와 상수를 올바르게 다루는 것은 견고한 Go 애플리케이션을 만드는 첫 단추입니다.
다음 포스트에서는 이러한 데이터를 실제로 다루는 입출력(I/O) 시스템에 대해 알아보겠습니다.
단순히 화면에 글자를 찍는 것을 넘어, Go 언어가 스트림(Stream)을 다루는 우아한 방식을 확인해보세요!