2. Variables

Alert

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

TL;DR

• Go는 변수 선언 시 자동으로 zero value를 할당하며, Python의 None과는 다른 개념
• 암시적 타입 변환이 없어 float64(x) 같은 명시적 변환 필수
• var는 zero value 초기화나 타입 명시가 필요할 때, :=는 나머지 상황에서 사용
• 선언 후 사용하지 않은 변수는 컴파일 에러 발생
• 네이밍은 camelCase 기반이며 첫 글자 대소문자로 공개 범위 결정

---

1. Zero Value - Python의 None과 다른 개념

Go에서 변수를 선언만 하면 자동으로 zero value가 할당된다. 타입별 기본값은 다음과 같다.

타입	Zero Value
int	0
float64	0.0
string	"" (빈 문자열)
bool	false
pointer	nil

Python은 변수를 초기화하지 않고 사용하면 NameError가 발생한다. Go는 선언만 해도 항상 기본값이 있다.

# Python - 초기화 없이 사용하면 에러
print(x)  # NameError: name 'x' is not defined

// Go - 선언만 해도 zero value가 할당됨
var x int
fmt.Println(x) // 0
 
var s string
fmt.Println(s) // "" (빈 문자열)
 
var b bool
fmt.Println(b) // false

Zero Value의 장점

• nil 체크나 초기화 여부를 별도로 확인할 필요가 줄어든다
• 구조체(struct)의 모든 필드도 zero value로 초기화되므로 생성자 없이도 안전하게 사용 가능

---

2. 기본 타입 - 정수, 부동소수점, 문자열, 불리언

정수

Go는 정수 크기를 명시할 수 있다.

var a int     // 플랫폼에 따라 32 또는 64비트
var b int8    // -128 ~ 127
var c int64   // -9223372036854775808 ~ 9223372036854775807
var d uint    // 부호 없는 정수
var e uint8   // 0 ~ 255

실무에서는 대부분 int를 사용한다. 특별한 이유(메모리 최적화, 바이너리 프로토콜 등)가 없으면 크기를 명시할 필요 없다.

Python은 정수 크기에 제한이 없다. 10 ** 1000도 그냥 된다. Go에서 같은 걸 하려면 math/big 패키지가 필요하다.

# Python - 정수 크기 제한 없음
x = 10 ** 1000  # 잘 동작함

// Go - 오버플로우 발생
var x int64 = 9223372036854775807
x = x + 1  // 오버플로우: -9223372036854775808

부동소수점

var f1 float32 = 3.14
var f2 float64 = 3.14  // 기본값, 대부분 이걸 사용

문자열

Go의 문자열은 Python과 마찬가지로 immutable이다. 큰따옴표와 백틱 두 가지 방식으로 작성한다.

s1 := "hello\nworld"   // 큰따옴표: 이스케이프 시퀀스 처리
s2 := `hello\nworld`   // 백틱(raw string): 이스케이프 무시, 줄바꿈 그대로 포함

예시에 나오는 :=

여기서 :=가 처음 나왔다. 변수를 선언하면서 값을 한 번에 할당하는 짧은 선언 문법으로, s1 := "hello"는 var s1 = "hello"와 같다. 앞으로 예시에 자주 등장하는데, var와의 차이와 선택 기준은 4번에서 따로 정리한다.

Python의 r"..." raw string과 Go의 백틱이 비슷한 역할이다.

불리언

Go는 다른 타입을 bool로 자동 변환하지 않는다. Python에서 흔히 쓰는 truthy/falsy 패턴이 Go에서는 통하지 않는다.

# Python - truthy/falsy 자동 변환
x = 0
if not x:       # 동작함
    print("zero")
 
items = []
if not items:   # 동작함
    print("empty")

// Go - 명시적 비교 필수
x := 0
if x == 0 {     // if x {} 는 컴파일 에러
    fmt.Println("zero")
}
 
items := []int{}
if len(items) == 0 {  // if items {} 는 컴파일 에러
    fmt.Println("empty")
}

byte와 rune — 특수 용도의 정수 별칭

Go에는 정수 타입 중 이름을 따로 붙여둔 별칭이 두 가지 있다.

• byte = uint8의 별칭. 0~255 사이의 8비트 정수 하나를 나타낸다.
• rune = int32의 별칭. 유니코드 문자(코드포인트) 하나를 나타낸다.

둘 다 내부적으로는 그냥 정수지만, uint8/int32 대신 byte/rune을 쓰면 “이 값이 어떤 용도인지” 코드에서 바로 드러난다.

byte — 바이너리 데이터를 다룰 때

파일 읽기, 네트워크 통신, 문자열 변환 등 I/O 관련 함수들은 대부분 []byte(바이트 슬라이스)를 반환한다.

// 파일 읽기 — 결과가 []byte
data, err := os.ReadFile("config.json")
 
// 문자열 ↔ 바이트 변환
b := []byte("hello")
fmt.Println(b)         // [104 101 108 108 111]
fmt.Println(string(b)) // "hello"

rune — 문자를 다룰 때

UTF-8에서 문자 하나가 차지하는 바이트 수는 문자마다 다르다.

문자 종류	바이트 수	예시
ASCII (영문, 숫자, 기호)	1바이트	A, 1, !
유럽 문자 (악센트 등)	2바이트	ñ, ü
한글, 한자, 일본어	3바이트	가, あ
이모지	4바이트	😀

rune이 int32(4바이트)인 이유가 여기에 있다. 어떤 문자든 최대 4바이트이므로, rune 하나면 어떤 유니코드 문자든 담을 수 있다. 반면 byte는 1바이트라서 ASCII만 1:1 대응되고, 한글 '가'는 byte 3개가 필요하다.

s := "가"
fmt.Println(len(s))          // 3 — 바이트 수
fmt.Println([]byte(s))       // [234 176 128] — byte 3개
fmt.Println([]rune(s))       // [44032] — rune 1개

Python과의 차이

Python에서는 bytes와 str이 완전히 다른 타입이다. Go에서 byte와 rune은 정수의 별칭일 뿐이라 타입 시스템이 구분해주지 않는다. 대신 개발자가 이름으로 의도를 드러낸다.

var b byte = 72        // "바이너리 데이터"라는 의도
var r rune = '가'       // "문자 처리"라는 의도
var b2 uint8 = 72      // 숫자 연산? 바이트? 모호함
var r2 int32 = '가'     // 숫자 연산? 문자? 모호함

문자열을 range로 순회할 때 byte와 rune의 차이가 실제로 드러나는데, 이 부분은 제어 구조 편에서 더 자세히 다룬다.

---

3. 명시적 타입 변환

Go는 암시적 타입 변환이 없다. 서로 다른 타입을 연산하면 컴파일 에러가 발생한다.

# Python - 암시적 변환
result = 10 + 3.14  # int가 자동으로 float로 변환
print(result)       # 13.14

// Go - 암시적 변환 없음
var x int = 10
var y float64 = 30.2
 
// z := x + y  // 컴파일 에러: mismatched types int and float64
 
var z float64 = float64(x) + y  // 명시적 변환 필수
fmt.Println(z) // 40.2

정수 타입끼리도 크기가 다르면 변환이 필요하다.

var a int32 = 10
var b int64 = 20
 
// c := a + b  // 컴파일 에러
c := int64(a) + b  // OK

왜 이렇게 엄격할까

• 암시적 변환은 예상치 못한 데이터 손실을 일으킬 수 있다 (예: float64 -> int 변환 시 소수점 버림)
• Go는 명시적으로 “나는 이 변환을 의도했다”고 표현하도록 강제한다

---

4. var vs := - 언제 뭘 쓰는가

Go에서 변수를 선언하는 방법은 크게 두 가지다.

var 키워드

var x int = 10    // 타입과 값을 모두 지정
var x = 10        // 타입 추론 (int로 추론됨)
var x int         // zero value로 초기화 (x = 0)

여러 변수를 한번에 선언할 수도 있다.

var (
    name   string
    age    int
    active bool
)

:= (짧은 선언)

x := 10           // var x = 10 과 동일
name := "gopher"  // var name = "gopher" 과 동일

:=의 타입 추론은 컴파일 타임에 일어난다

:=는 오른쪽 값의 타입을 보고 변수 타입을 자동으로 정한다(10 → int, "gopher" → string). 단 이 추론은 컴파일 시점에 오른쪽 표현식의 타입을 보고 못 박는 것이지, 실행 중에 값에 따라 타입이 바뀌는 게 아니다. Go는 정적 타입 언어이고, :=는 타입을 두 번 쓰지 않게 해주는 단축 문법일 뿐이다.

x := 10
x = "hello"   // 컴파일 에러 — x는 영원히 int

Python의 x = 10은 나중에 x = "hello"로 바꿔도 되지만(동적 타입), Go의 :=는 변수에 정적 타입을 고정한다. 그래서 컴파일러가 컴파일 시점에 타입을 알 수 없는 값(예: 모양을 모르는 외부 JSON)에는 :=를 쓸 수 없고, 그런 경우는 07편의 any로 다룬다.

:=는 함수 안에서만 사용 가능하다. 패키지 레벨(함수 바깥)에서는 반드시 var를 써야 한다.

package main
 
var packageLevel = "OK"     // var만 가능
// badVar := "에러"          // 컴파일 에러: 패키지 레벨에서 := 사용 불가
 
func main() {
    localVar := "OK"        // 함수 안에서는 := 사용 가능
    fmt.Println(localVar)
}

선택 기준

상황	선택
zero value로 초기화하고 싶을 때	var x int
타입을 명시적으로 지정해야 할 때	var x float64 = 10
패키지 레벨 변수	var
그 외 함수 내부	:=

:= 사용을 피해야 하는 상황

:=는 편리하지만, 다음 경우에는 var가 더 낫다.

1. zero value로 초기화할 때 :=를 쓰면 반드시 오른쪽에 값이 있어야 한다. zero value가 목적이면 var가 의도를 명확하게 드러낸다.

var count int          // "zero value로 시작한다"는 의도가 명확
count := 0             // 동작은 같지만 0이 의미 있는 값인지 zero value인지 모호

2. 타입을 명시해야 할 때 리터럴¹이나 타입 미지정 상수를 할당할 때, 기본 추론 타입이 원하는 타입과 다를 수 있다.

var ratio float64 = 10   // 10이지만 float64로 사용할 것임을 명시
ratio := 10              // int로 추론됨 — 의도와 다를 수 있음

3. 섀도잉 실수를 방지할 때 :=는 항상 새 변수를 만들 수 있어서, 바깥 변수를 수정하려다 실수로 새 변수를 만들게 된다. var로 선언하면 이후에는 =만 쓰게 되므로 이런 실수를 줄일 수 있다.

x := 10
if true {
    x := 20           // 새로운 x가 생김 (바깥 x와 다른 변수!)
    fmt.Println(x)    // 20
}
fmt.Println(x)        // 10 — 바깥 x는 그대로
 
// 의도적으로 바깥 변수를 수정하려면 = 사용
x = 20

정리

• :=는 “새 변수 만들기 + 값 할당”을 동시에 한다
• var로 먼저 선언하면 이후 =로만 값을 바꾸므로, 새 변수가 생기는 실수를 방지할 수 있다
• 같은 스코프에서 :=를 쓰면 기존 변수를 재사용하지만, 안쪽 블록(if, for 등)에서 쓰면 새 변수가 만들어진다

---

5. 상수 (const)

Go에서 상수는 쉽게 말해 리터럴에 이름을 붙이는 방법이다. 3.14159라는 숫자를 코드 곳곳에 쓰는 대신 pi라는 이름을 붙여서 쓰는 것이다.

const pi = 3.14159
const greeting = "hello"
const isDebug = false

단, Go의 const는 컴파일 타임에 값을 확정할 수 있는 것만 가능하다. 그래서 상수로 쓸 수 있는 타입이 제한적이다.

// 가능: 숫자, 문자열, bool, rune
const maxRetry = 3
const name = "gopher"
 
// 불가능: 런타임에 만들어지는 값
// const items = []int{1, 2, 3}   // 컴파일 에러: slice
// const now = time.Now()         // 컴파일 에러: 함수 호출 결과

JavaScript의 const는 “재할당 금지”이고, Python에는 아예 const 키워드가 없다(대문자 변수명 MAX_SIZE = 100은 관례일 뿐 재할당이 가능하다). Go의 const는 둘 다와 다르게 “컴파일 타임에 값이 결정되는 것만 허용”하는 진짜 상수다.

타입 미지정 상수의 유연함

타입을 지정하지 않은 상수는 리터럴처럼 유연하게 동작한다. const x = 10에서 10이 리터럴이듯, x도 아직 타입이 정해지지 않은 상태다. 그래서 여러 타입의 변수에 할당할 수 있다.

const x = 10  // 타입 미지정 상수 — 리터럴 10에 이름만 붙인 것
 
var a int = x       // OK
var b float64 = x   // OK
var c int64 = x     // OK

타입을 지정하면 해당 타입으로 고정된다.

const x int = 10
 
var a int = x       // OK
// var b float64 = x   // 컴파일 에러: int를 float64에 할당 불가

---

6. 사용 안 하면 컴파일 에러

Go는 선언한 변수를 사용하지 않으면 컴파일 자체가 안 된다. import도 마찬가지다.

func main() {
    x := 10   // 컴파일 에러: x declared and not used
}

import "fmt"  // 컴파일 에러: "fmt" imported and not used
 
func main() {}

Python은 미사용 변수나 import가 있어도 경고조차 뜨지 않는다(린터를 따로 설정하지 않는 한). Go는 언어 차원에서 강제한다.

패키지 레벨 변수는 예외 — 그래서 더 주의해야 한다

여기서 “패키지 레벨”이란 함수 바깥, 파일 최상위에 선언하는 변수를 말한다.

package main
 
var globalCount int  // 패키지 레벨 변수 — 함수 바깥에 선언
 
func main() {
    localVar := 10   // 지역 변수 — 함수 안에 선언
}

문제는 Go 컴파일러가 패키지 레벨 변수는 미사용 검사를 하지 않는다는 것이다. 선언만 해놓고 아무 데서도 안 써도 컴파일이 잘 된다. 컴파일러가 잡아주지 않으니 죽은 코드가 쌓이기 쉽다.

그래서 패키지 레벨에서는 변수 선언을 최소화하고, 꼭 필요하다면 사실상 변경하지 않을 값(상수에 가까운 것)만 두는 것이 좋다.

_ 로 명시적 무시

값을 받아야 하지만 사용하지 않을 때는 _(blank identifier)를 사용한다.

// 함수가 두 값을 반환하는데 하나만 필요할 때
value, _ := someFunction()
 
// range에서 인덱스가 필요 없을 때
for _, item := range items {
    fmt.Println(item)
}

Python의 _ 관례와 비슷하지만, Go에서는 이걸 안 쓰면 컴파일 에러가 나니 선택이 아니라 필수다.

---

7. 네이밍 컨벤션

Go는 snake_case가 아니라 camelCase를 사용한다.

// Go 스타일
userName := "gopher"
maxRetryCount := 3
isActive := true
 
// Python 스타일 (Go에서는 비권장)
// user_name := "gopher"
// max_retry_count := 3

첫 글자 대소문자 = 공개 범위

Go에서 가장 독특한 네이밍 규칙이다. 첫 글자가 대문자면 exported(다른 패키지에서 접근 가능), 소문자면 unexported(패키지 내부 전용)이다.

package user
 
var MaxAge = 150       // exported: 다른 패키지에서 user.MaxAge로 접근 가능
var defaultRole = "guest"  // unexported: 패키지 내부에서만 사용
 
func GetName() string { ... }   // exported
func validate() bool { ... }    // unexported

Python에서는 _ 접두사로 비공개를 표시하는 관례가 있지만, 실제로 접근을 막지는 않는다.

# Python - 관례적 비공개 (실제로는 접근 가능)
class User:
    def __init__(self):
        self._name = "private"     # 관례적 비공개
        self.__secret = "hidden"   # name mangling (여전히 접근 가능)
 
u = User()
print(u._name)           # 접근 가능 (경고만)
print(u._User__secret)   # 이것도 접근 가능

Go는 컴파일러가 접근 제어를 강제한다. unexported 식별자는 다른 패키지에서 아예 사용할 수 없다.

요약: Python vs Go 네이밍

• Python: snake_case, _prefix로 비공개 표시 (관례)
• Go: camelCase, 첫 글자 대문자/소문자로 공개 범위 결정 (컴파일러 강제)

Footnotes

1. 리터럴(literal)은 코드에 직접 쓴 값 그 자체를 말한다. 42, "hello", 3.14 같은 것들이 리터럴이다. 변수명은 값을 가리키는 이름이고, 리터럴은 이름 없이 코드에 박혀 있는 날것의 값이다. ↩