4. Control Flow

Alert

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

TL;DR

• Go의 반복문은 for 하나뿐이며 while, do-while 키워드가 없음
• range가 넘기는 값은 복사본이라 원본 수정은 인덱스 접근으로 해야 함
• 중첩 루프는 레이블(break outer)로 한 번에 빠져나갈 수 있음
• range로 문자열 순회 시 바이트 인덱스와 rune 단위 값을 반환하므로 Python의 문자 단위 순회와 다름
• if문에 초기화 구문을 넣을 수 있고, 변수 스코프가 블록 단위로 제한됨
• := 섀도잉은 Go 초보자가 가장 많이 겪는 버그 원인 중 하나
• switch는 자동 break이며 fallthrough로 다음 case에 이어 실행 가능

1. for 하나로 전부 — Go에는 while이 없다

Python에는 for, while, 리스트 컴프리헨션 등 반복 구문이 여럿 있지만, Go는 for 키워드 하나로 모든 반복을 처리한다.

1-1. C-style for loop

for i := 0; i < 10; i++ {
    fmt.Println(i)
}

for i in range(10):
    print(i)

초기화(; 앞), 조건(; 사이), 후처리(; 뒤) 세 부분으로 구성된다. Python의 range()가 이 세 가지를 한번에 처리해주는 것과 비교하면 좀 더 명시적이다.

1-2. 조건식만 (= while)

i := 1
for i < 100 {
    i *= 2
}

i = 1
while i < 100:
    i *= 2

초기화와 후처리를 빼면 while과 동일하게 동작한다.

1-3. 무한 루프

for {
    // break 또는 return으로 탈출
}

while True:
    # break 또는 return으로 탈출

조건식마저 빼면 무한 루프가 된다. while True:보다 타이핑이 짧다.

1-4. for-range (= for-in)

nums := []int{10, 20, 30}
for i, v := range nums {
    fmt.Println(i, v)
}

nums = [10, 20, 30]
for i, v in enumerate(nums):
    print(i, v)

range는 슬라이스, 맵, 문자열, 채널 등 다양한 타입에 사용할 수 있다.

맵 순회

m := map[string]int{"a": 1, "b": 2}
for k, v := range m {
    fmt.Println(k, v)
}

d = {"a": 1, "b": 2}
for k, v in d.items():
    print(k, v)

불필요한 값 무시

인덱스나 값이 필요 없으면 _로 무시할 수 있다. 이 관례는 Python과 동일하다.

for _, v := range nums {
    fmt.Println(v)
}
 
for i := range nums {
    fmt.Println(i) // 인덱스만 필요할 때는 두 번째 변수를 아예 생략
}

for-range의 값은 복사본이다

range가 넘겨주는 값은 원본 요소가 아니라 복사본이다. 그래서 루프 변수를 수정해도 원본 슬라이스는 바뀌지 않는다.

nums := []int{10, 20, 30}
for _, v := range nums {
    v *= 2 // 복사본만 수정됨
}
fmt.Println(nums) // [10 20 30] — 원본 그대로

원본을 바꾸려면 인덱스로 직접 접근해야 한다.

for i := range nums {
    nums[i] *= 2 // 원본 수정
}
fmt.Println(nums) // [20 40 60]

구조체 슬라이스에서 특히 실수하기 쉽다. 복사본의 필드를 바꿔봐야 원본에는 반영되지 않는다.

type Point struct{ X, Y int }
points := []Point{{1, 2}, {3, 4}}
 
for _, p := range points {
    p.X = 100 // 복사본의 필드 — 무의미
}
fmt.Println(points) // [{1 2} {3 4}] — 변화 없음
 
for i := range points {
    points[i].X = 100 // 원본 수정
}
fmt.Println(points) // [{100 2} {100 4}]

Python과의 차이

Python에서 for item in list로 받은 item도 재할당(item = ...)하면 원본이 안 바뀌는 건 같다. 하지만 item이 리스트나 객체면 item.attr = ...이나 item.append(...)로 내부를 수정할 수 있다. Go의 값 타입(구조체, 배열)은 복사본이라 이런 내부 수정조차 원본에 반영되지 않는다. 슬라이스/맵 같은 참조 타입은 복사본이어도 내부 데이터를 공유하므로 수정이 반영된다.

1-5. 레이블링 — 중첩 루프 한 번에 빠져나가기

break와 continue는 기본적으로 가장 안쪽 루프에만 적용된다. 중첩 루프에서 바깥 루프까지 제어하려면 레이블을 붙인다.

outer:
for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i*j > 2 {
            break outer // 바깥 루프까지 한 번에 탈출
        }
        fmt.Println(i, j)
    }
}

continue도 레이블과 함께 쓸 수 있다. 안쪽 루프를 중단하고 바깥 루프의 다음 반복으로 넘어간다.

outer:
for _, row := range matrix {
    for _, v := range row {
        if v < 0 {
            continue outer // 음수를 만나면 이 행을 버리고 다음 행으로
        }
        fmt.Println(v)
    }
}

Python에는 레이블 문법이 없다. 같은 동작을 하려면 플래그 변수를 두거나 함수로 분리해서 return으로 빠져나오는 식으로 우회한다.

# Python — 플래그로 우회
done = False
for i in range(3):
    for j in range(3):
        if i * j > 2:
            done = True
            break
    if done:
        break

레이블 작성 관례

레이블 이름은 루프 바로 앞에 콜론(:)과 함께 쓰고, 들여쓰기하지 않는다. 깊은 중첩이 자주 생기면 레이블보다 함수로 분리하는 것을 먼저 고려하는 편이 낫다.

---

2. range와 문자열 — 바이트 vs 룬

Python에서 문자열을 순회하면 항상 문자(유니코드 코드포인트) 단위로 처리된다. Go는 다르다.

Go의 문자열은 내부적으로 바이트 슬라이스([]byte)다. range로 문자열을 순회하면 인덱스는 바이트 위치, 값은 rune(유니코드 코드포인트) 으로 반환된다.

s := "apple_π!"
for i, r := range s {
    fmt.Printf("i=%d r=%c\n", i, r)
}

출력 결과:

i (바이트 인덱스)	r (rune)	바이트 수
0	a	1
1	p	1
2	p	1
3	l	1
4	e	1
5	_	1
6	π	2
8	!	1

π는 UTF-8로 2바이트를 차지하기 때문에 인덱스가 6에서 8로 점프한다. ASCII 문자만 다루다가 다국어 문자열을 만나면 인덱스 계산이 틀어질 수 있으니 주의해야 한다.

Python과의 차이

Python에서 enumerate("apple_π!")를 하면 인덱스가 0, 1, 2, … 8까지 순서대로 증가한다. Python의 str은 내부적으로 유니코드 코드포인트 단위로 인덱싱하기 때문이다.

바이트 단위로 순회하고 싶다면 range를 쓰지 말고 인덱스로 직접 접근하면 된다.

for i := 0; i < len(s); i++ {
    fmt.Printf("byte[%d] = %x\n", i, s[i])
}

---

3. if문 — 초기화 구문이 있는 if

Go의 if는 조건식 앞에 초기화 구문을 넣을 수 있다. 이 변수는 if-else 블록 안에서만 유효하다.

if n := rand.Intn(10); n == 0 {
    fmt.Println("too low")
} else if n > 5 {
    fmt.Println("too big:", n)
} else {
    fmt.Println("good:", n)
}
// 여기서 n을 쓰면 컴파일 에러

Python에는 이런 문법이 없다. 가장 비슷한 것은 walrus operator(:=)지만 스코프 동작이 다르다.

import random
 
# walrus operator — n이 바깥 스코프에서도 유효함
if (n := random.randint(0, 9)) == 0:
    print("too low")
elif n > 5:
    print(f"too big: {n}")
else:
    print(f"good: {n}")
 
print(n)  # 여전히 접근 가능

핵심 차이

• Go: if 초기화 구문의 변수는 if-else 블록이 끝나면 사라진다
• Python: walrus operator로 선언한 변수는 바깥 스코프에서도 살아있다

이 패턴은 에러 처리에서 특히 자주 쓰인다.

if err := doSomething(); err != nil {
    return err
}
// err은 여기서 접근 불가 — 스코프가 깔끔하게 정리됨

---

4. 블록 스코프와 섀도잉

Go는 중괄호({}) 블록 단위로 스코프가 결정된다. Python의 함수 단위 스코프(LEGB 규칙)와 근본적으로 다르다.

4-1. 기본 블록 스코프

x := 10
if true {
    x := 20  // 새로운 x — 바깥 x를 가린다(shadow)
    fmt.Println(x) // 20
}
fmt.Println(x) // 10

:=는 새 변수를 선언하는 연산자다. 안쪽 블록에서 :=를 쓰면 바깥 변수와 이름이 같아도 완전히 별개의 변수가 만들어진다.

Python에서는 같은 이름에 할당하면 바깥 변수를 덮어쓴다.

x = 10
if True:
    x = 20  # 바깥 x를 덮어씀
    print(x)  # 20
print(x)  # 20

4-2. err 섀도잉 함정

실무에서 가장 자주 문제가 되는 경우다.

var err error
 
err = step1() // 바깥 err에 할당
if err != nil {
    return err
}
 
if true {
    err := step2() // 새로운 err! 바깥 err을 가림
    // 이 err은 블록이 끝나면 사라진다
    _ = err
}
 
fmt.Println(err) // step1()의 에러값 — step2() 결과는 반영 안 됨

같은 스코프에서 :=를 쓰면 이미 선언된 변수를 재사용하지만, 안쪽 블록에서 :=를 쓰면 새 변수가 된다. 이 차이를 놓치면 에러를 삼키는 버그가 생긴다.

해결 방법

• 바깥 변수에 할당하려면 =를 사용한다 (:= 대신)
• go vet -shadow 또는 shadow 린터로 섀도잉을 검출할 수 있다
• golangci-lint에 shadow 관련 린터를 활성화하면 CI에서 자동으로 잡아준다

4-3. 유니버스 블록 식별자 섀도잉

len, cap, make, append, new, true, false 등은 Go의 유니버스 블록(최상위 스코프)에 정의된 식별자다. 이것들도 섀도잉이 가능하다.

len := 10 // 컴파일 에러 안 남! 하지만 이후 len() 함수를 쓸 수 없음

이런 이름은 변수명으로 사용하지 않는 것이 좋다. Python에서 list = [1, 2, 3]으로 빌트인을 덮어쓰는 실수와 같은 맥락이다.

---

5. switch — Python match/case보다 유연하다

Go의 switch는 C/C++과 달리 break가 필요 없다. 매칭되는 case를 실행하면 자동으로 빠져나온다.

switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("macOS")
case "linux":
    fmt.Println("Linux")
default:
    fmt.Println(os)
}

import platform
 
match platform.system():
    case "Darwin":
        print("macOS")
    case "Linux":
        print("Linux")
    case os:
        print(os)

Go switch가 더 유연한 부분

하나의 case에 여러 값을 콤마로 나열할 수 있다.

switch day {
case "Sat", "Sun":
    fmt.Println("weekend")
default:
    fmt.Println("weekday")
}

비교 대상 없이 switch만 쓰면 if-else 체인을 대체할 수 있다.

switch {
case n < 0:
    fmt.Println("negative")
case n == 0:
    fmt.Println("zero")
default:
    fmt.Println("positive")
}

fallthrough — 다음 case로 떨어뜨리기

Go는 기본이 자동 break라서, C처럼 다음 case로 이어서 실행하려면 fallthrough를 명시해야 한다. 현재 case의 코드를 실행한 뒤 바로 다음 case의 코드까지 조건 검사 없이 실행한다.

switch n := 2; n {
case 2:
    fmt.Println("2")
    fallthrough // 다음 case로 떨어진다
case 1:
    fmt.Println("1")
    fallthrough
case 0:
    fmt.Println("0")
}
// 출력:
// 2
// 1
// 0

fallthrough는 다음 case의 조건을 확인하지 않고 무조건 실행한다. 이 점을 놓치기 쉽다. 위에서 n이 2여도 case 1, case 0의 본문이 모두 실행된다.

누적되는 등급 처리 같은 곳에서 가끔 쓰지만, 의도를 헷갈리게 만들기 쉬워서 실무에서는 거의 쓰지 않는다. 대부분은 콤마로 여러 값을 나열하는 방식으로 충분하다.

# Python match/case에는 fallthrough가 없다 — 여러 값은 | 로 묶는다
match command:
    case "start" | "run":
        print("실행")
    case "stop":
        print("중지")

if문처럼 switch에도 초기화 구문을 넣을 수 있다. 위의 os := runtime.GOOS, n := 2 부분이 그 예시다.