Go 기초 문법 완전 정리

Go code

package main

import "fmt"

// 패키지 레벨 변수 — var만 가능
var (
	appName    = "MyApp"
	maxRetries = 3
	debug      bool // zero value: false
)

// 상수
const (
	Pi      = 3.14159
	Version = "1.0.0"

	// iota — 자동 증가 상수
	Sunday = iota
	Monday
	Tuesday
	Wednesday
)

func main() {
	// var 선언
	var name string = "Go"
	var age int     // zero value: 0
	var ratio float64 // zero value: 0.0

	// 단축 선언 := (함수 내부에서만)
	lang    := "Go"
	version := 1.22
	active  := true

	// 다중 선언
	x, y, z := 1, 2, 3

	// zero value 확인
	var s string  // ""
	var n int     // 0
	var b bool    // false
	var p *int    // nil

	fmt.Printf("name=%s age=%d ratio=%f
", name, age, ratio)
	fmt.Printf("lang=%s v=%.2f active=%t
", lang, version, active)
	fmt.Println(x, y, z)
	fmt.Printf("zeros: %q %d %t %v
", s, n, b, p)
}

Go code

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// 정수 타입
	var i8  int8   = 127
	var i32 int32  = 2_147_483_647
	var i64 int64  = 9_223_372_036_854_775_807
	var u   uint   = 255

	// 부동소수점
	var f32 float32 = 3.14
	var f64 float64 = 3.141592653589793

	// 타입 변환 — 반드시 명시적
	a := 42
	b := float64(a)     // int → float64
	c := int(f64)       // float64 → int (소수점 버림)
	d := uint(a)        // int → uint

	// 문자열 변환 (strconv 패키지)
	n, err := strconv.Atoi("42")        // string → int
	if err != nil {
		fmt.Println("변환 실패:", err)
	}
	s := strconv.Itoa(100)              // int → string
	f, _ := strconv.ParseFloat("3.14", 64) // string → float64
	bs := strconv.FormatBool(true)      // bool → string

	// rune = int32 (유니코드 코드포인트)
	var r rune = '한'
	fmt.Printf("rune: %c (%d)
", r, r)

	// byte = uint8
	var by byte = 'A'
	fmt.Printf("byte: %c (%d)
", by, by)

	_ = i8; _ = i32; _ = i64; _ = u
	_ = f32; _ = b; _ = c; _ = d
	_ = n; _ = s; _ = f; _ = bs
}

Go code

package main

import "fmt"

func main() {
	// if — 초기화 구문 포함 가능
	if x := 42; x > 40 {
		fmt.Println("x는 40보다 큼:", x)
	}

	// for — 기본 (C의 for)
	for i := 0; i < 5; i++ {
		fmt.Print(i, " ")
	}
	fmt.Println()

	// for — while처럼
	n := 1
	for n < 100 {
		n *= 2
	}
	fmt.Println("n:", n)

	// for — 무한루프
	count := 0
	for {
		count++
		if count >= 3 {
			break
		}
	}

	// for range — 슬라이스/맵/채널
	fruits := []string{"🍎", "🍌", "🍇"}
	for i, v := range fruits {
		fmt.Printf("%d: %s
", i, v)
	}
	// 인덱스만
	for i := range fruits { _ = i }
	// 값만
	for _, v := range fruits { _ = v }

	// switch — fallthrough 없음 (기본)
	score := 85
	switch {
	case score >= 90:
		fmt.Println("A")
	case score >= 80:
		fmt.Println("B")
	default:
		fmt.Println("C 이하")
	}

	// switch — 타입 스위치
	var i interface{} = "hello"
	switch v := i.(type) {
	case int:    fmt.Println("int:", v)
	case string: fmt.Println("string:", v)
	default:     fmt.Println("unknown")
	}
}

Go code

package main

import "fmt"

func increment(n *int) {
	*n++   // 역참조로 원본 수정
}

func newInt(val int) *int {
	// 로컬 변수 주소 반환 OK — Go GC가 관리
	return &val
}

func main() {
	x := 42
	p := &x    // p는 x의 주소를 가리키는 포인터

	fmt.Println("값:", x)           // 42
	fmt.Println("주소:", p)         // 0xc0000b4008 (예시)
	fmt.Println("역참조:", *p)      // 42

	*p = 100   // 포인터를 통해 값 변경
	fmt.Println("변경 후:", x)      // 100

	// 함수로 포인터 전달
	increment(&x)
	fmt.Println("increment 후:", x) // 101

	// new() — 제로값으로 초기화된 포인터 반환
	q := new(int)   // *int, 값은 0
	*q = 50
	fmt.Println("new:", *q)

	// nil 포인터 확인
	var ptr *int
	fmt.Println("nil?", ptr == nil) // true
	// fmt.Println(*ptr)            // 패닉! nil 역참조

	r := newInt(99)
	fmt.Println("힙 할당:", *r) // 99
}

Go code

package main

import (
	"fmt"
	"strings"
	"unicode/utf8"
)

func main() {
	s := "Hello, 세계"

	// 바이트 vs rune
	fmt.Println("바이트 길이:", len(s))               // 13
	fmt.Println("문자(rune) 수:", utf8.RuneCountInString(s)) // 9

	// 바이트 순회 (한글 깨짐)
	for i, b := range []byte(s) {
		if i < 7 { fmt.Printf("%d:%c ", i, b) }
	}
	fmt.Println()

	// rune 순회 (올바른 한글 처리)
	for i, r := range s {
		fmt.Printf("%d:%c ", i, r)
	}
	fmt.Println()

	// rune 슬라이싱
	runes := []rune(s)
	fmt.Println("첫 5자:", string(runes[:5]))  // Hello

	// strings 패키지
	fmt.Println(strings.ToUpper("hello"))        // HELLO
	fmt.Println(strings.Contains(s, "세계"))     // true
	fmt.Println(strings.HasPrefix(s, "Hello"))   // true
	fmt.Println(strings.Replace(s, "Hello", "Hi", 1))
	fmt.Println(strings.Split("a,b,c", ","))     // [a b c]
	fmt.Println(strings.Join([]string{"x","y"}, "-")) // x-y
	fmt.Println(strings.TrimSpace("  hello  "))  // hello
	fmt.Println(strings.Count(s, "l"))            // 2

	// strings.Builder — 효율적 문자열 조합
	var b strings.Builder
	for i := 0; i < 5; i++ {
		fmt.Fprintf(&b, "item%d ", i)
	}
	fmt.Println(b.String())
}

Go code

package main

import "fmt"

// 타입 정의 — 새 타입 (메서드 추가 가능)
type Celsius    float64
type Fahrenheit float64
type UserID     int
type ProductID  int

// 타입에 메서드 추가
func (c Celsius) ToFahrenheit() Fahrenheit {
	return Fahrenheit(c*9/5 + 32)
}

func (f Fahrenheit) ToCelsius() Celsius {
	return Celsius((f - 32) * 5 / 9)
}

// 컴파일 타임 타입 안전성
func findOrder(uid UserID, pid ProductID) string {
	return fmt.Sprintf("user:%d, product:%d", uid, pid)
}

// 타입 별칭 — 완전히 동일한 타입
type MyInt = int  // 메서드 추가 불가

// Stringer 구현
func (uid UserID) String() string {
	return fmt.Sprintf("UID(%d)", int(uid))
}

func main() {
	boiling := Celsius(100)
	fmt.Printf("%.1f°C = %.1f°F
", boiling, boiling.ToFahrenheit())

	body := Fahrenheit(98.6)
	fmt.Printf("%.1f°F = %.2f°C
", body, body.ToCelsius())

	// 타입 안전성
	order := findOrder(UserID(1), ProductID(42))
	fmt.Println(order)

	// findOrder(42, 1)               // 컴파일 에러!
	// findOrder(ProductID(42), UserID(1)) // 컴파일 에러!

	uid := UserID(123)
	fmt.Println(uid)  // UID(123) — Stringer 호출
}

Go code

<span class="cm">// slog 구조화 로깅 (Go 1.21+) 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("slog 구조화 로깅 (Go 1.21+)") }

Go code

package main

import "fmt"

func increment(p *int) {
	if p == nil {
		return // nil 안전 처리
	}
	*p++
}

func main() {
	x := 10
	increment(&x)
	fmt.Println(x) // 11

	// 포인터로 구조체 필드 수정
	type User struct{ Name string }
	u := &User{Name: "Go"}
	u.Name = "Gopher" // (*u).Name과 동일
	fmt.Println(u.Name)

	// new로 포인터 생성
	p := new(int) // *int, 0으로 초기화
	*p = 42
	fmt.Println(*p)
}

Go code

package main

import "fmt"

type Rect struct {
	Width, Height float64
}

// 값 리시버 — 원본 변경 불가
func (r Rect) Area() float64 {
	return r.Width * r.Height
}

// 포인터 리시버 — 원본 수정 가능
func (r *Rect) Scale(factor float64) {
	r.Width *= factor
	r.Height *= factor
}

func (r Rect) String() string {
	return fmt.Sprintf("Rect(%.1f x %.1f)", r.Width, r.Height)
}

func main() {
	r := Rect{Width: 3, Height: 4}
	fmt.Println(r.Area())  // 12
	r.Scale(2)
	fmt.Println(r) // Rect(6.0 x 8.0)
}

Go code

package main

import "fmt"

func describe(i any) string {
	// 콤마-ok 패턴 (안전)
	if s, ok := i.(string); ok {
		return "문자열: " + s
	}
	if n, ok := i.(int); ok {
		return fmt.Sprintf("정수: %d", n)
	}
	return "알 수 없는 타입"
}

func main() {
	var v any = "Hello"
	s := v.(string)   // 확실할 때만 사용
	fmt.Println(s)

	fmt.Println(describe("Go"))
	fmt.Println(describe(42))
	fmt.Println(describe(3.14))
}

Go code

package main

import "fmt"

func classify(v any) string {
	switch x := v.(type) {
	case nil:
		return "nil 값"
	case int, int64:
		return fmt.Sprintf("정수: %v", x)
	case string:
		return "문자열 길이: " + fmt.Sprint(len(x))
	case bool:
		if x {
			return "참"
		}
		return "거짓"
	case []int:
		return fmt.Sprintf("정수 슬라이스 (%d개)", len(x))
	default:
		return fmt.Sprintf("기타: %T", x)
	}
}

func main() {
	values := []any{42, "Go", true, nil, []int{1, 2}}
	for _, v := range values {
		fmt.Println(classify(v))
	}
}

Go code

package main

import "fmt"

type Weekday int

const (
	Sunday Weekday = iota // 0
	Monday                // 1
	Tuesday               // 2
	Wednesday             // 3
)

// 비트 플래그 패턴
type Permission int

const (
	Read    Permission = 1 << iota // 1
	Write                          // 2
	Execute                        // 4
)

func (p Permission) String() string {
	s := ""
	if p&Read != 0 { s += "r" }
	if p&Write != 0 { s += "w" }
	if p&Execute != 0 { s += "x" }
	return s
}

func main() {
	fmt.Println(Monday)  // 1
	perm := Read | Write
	fmt.Println(perm)    // rw
}

Go code

package main

import "fmt"

// 타입 정의 — 새로운 타입 (기존 메서드 상속 안 됨)
type UserID int64
type Email string

// 타입 별칭 — 완전히 동일한 타입
type Byte = uint8

func sendEmail(to Email, msg string) {
	fmt.Printf("To: %s, Msg: %s\n", to, msg)
}

func main() {
	var id UserID = 100
	var email Email = "user@go.dev"

	// id + 1 → 컴파일 에러 (타입 불일치)
	id = UserID(int64(id) + 1)
	fmt.Println(id)

	sendEmail(email, "Hello!")
	// sendEmail("raw@go.dev", "Hi") // 컴파일 에러
	sendEmail(Email("raw@go.dev"), "Hi") // 명시적 변환 필요
}

Go code

package main

import "fmt"

type Logger struct{}

func (l Logger) Log(msg string) {
	fmt.Println("[LOG]", msg)
}

type Server struct {
	Logger // 임베딩 (이름 없는 필드)
	Host   string
	Port   int
}

func (s Server) Start() {
	s.Log(fmt.Sprintf("서버 시작: %s:%d", s.Host, s.Port))
}

func main() {
	srv := Server{Host: "localhost", Port: 8080}
	srv.Start()
	srv.Log("직접 호출도 가능") // Logger.Log가 승격됨
}

Go code

package main

import "fmt"

// any는 interface{}의 별칭 (Go 1.18+)
func printAll(values ...any) {
	for i, v := range values {
		fmt.Printf("[%d] %T = %v\n", i, v, v)
	}
}

// 타입 안전한 대안: 제네릭
func first[T any](slice []T) (T, bool) {
	if len(slice) == 0 {
		var zero T
		return zero, false
	}
	return slice[0], true
}

func main() {
	printAll("Go", 42, true, 3.14)

	v, ok := first([]string{"a", "b"})
	fmt.Println(v, ok) // a true
}

Go code

package main

import "fmt"

// comparable 제약: == 연산 가능한 타입만 허용
func contains[T comparable](slice []T, target T) bool {
	for _, v := range slice {
		if v == target {
			return true
		}
	}
	return false
}

func main() {
	// 비교 가능: 숫자, 문자열, bool, 포인터, 채널, 배열
	fmt.Println(contains([]int{1, 2, 3}, 2))       // true
	fmt.Println(contains([]string{"a", "b"}, "c"))  // false

	// 구조체도 모든 필드가 comparable이면 비교 가능
	type Point struct{ X, Y int }
	fmt.Println(Point{1, 2} == Point{1, 2}) // true

	// 슬라이스, 맵, 함수는 비교 불가
	// []int{1} == []int{1} // 컴파일 에러
}

Go code

package main

import (
	"fmt"
	"strings"
	"unicode/utf8"
)

func main() {
	s := "Hello, 세계! 🌍"

	fmt.Println("바이트 길이:", len(s))
	fmt.Println("문자 수:", utf8.RuneCountInString(s))

	// range는 rune 단위로 순회
	for i, r := range s {
		if r == '세' {
			fmt.Printf("'세' at byte %d\n", i)
		}
	}

	// 문자열 빌더 (효율적 연결)
	var b strings.Builder
	for i := 0; i < 5; i++ {
		fmt.Fprintf(&b, "%d ", i)
	}
	fmt.Println(b.String()) // 0 1 2 3 4
}

Go code

package main

import "fmt"

const (
	Pi      = 3.14159265358979 // 타입 없는 상수
	MaxSize = 1024
	Prefix  = "go_"
)

// 타입 있는 상수
const TypedMax int64 = 1<<63 - 1

func main() {
	// 타입 없는 상수는 문맥에 맞게 변환
	var f32 float32 = Pi  // float32로 사용
	var f64 float64 = Pi  // float64로 사용
	fmt.Println(f32, f64)

	// 큰 정밀도 유지
	const big = 1e1000 // 컴파일 타임에만 존재 가능
	fmt.Println(big / 1e999) // 10
}

Go code

package main

import "fmt"

var global = initGlobal()

func initGlobal() int {
	fmt.Println("1. 패키지 변수 초기화")
	return 42
}

func init() {
	fmt.Println("2. init() 실행")
	// DB 연결, 설정 로드 등
}

func init() {
	// 같은 파일에 여러 init 가능
	fmt.Println("3. 두 번째 init() 실행")
}

func main() {
	fmt.Println("4. main() 실행")
	fmt.Println("global =", global)
}

Go code

package main

import "fmt"

// 공개 타입 (다른 패키지에서 접근 가능)
type User struct {
	Name  string // 공개 필드
	Email string // 공개 필드
	age   int    // 비공개 필드
}

// 공개 생성자 — 비공개 필드 설정에 사용
func NewUser(name, email string, age int) *User {
	return &User{Name: name, Email: email, age: age}
}

// 비공개 함수
func validate(email string) bool {
	return len(email) > 0
}

func main() {
	u := NewUser("Gopher", "go@dev", 5)
	fmt.Println(u.Name) // OK
	// fmt.Println(u.age) // 같은 패키지라 OK, 다른 패키지면 에러
}

Go code

package main

import "fmt"

// 디렉토리 구조:
// myapp/
// ├── cmd/server/main.go        ← internal 사용 가능
// ├── internal/
// │   ├── auth/auth.go          ← 외부 import 불가
// │   ├── db/db.go              ← 외부 import 불가
// │   └── config/config.go
// └── pkg/api/api.go            ← 외부 import 가능

// internal/config/config.go 예시:
// package config
// type Config struct {
//     DBHost string
//     Port   int
// }

func main() {
	fmt.Println("internal/ → 모듈 내부에서만 접근")
	fmt.Println("pkg/      → 외부에서도 접근 가능")
	fmt.Println("컴파일러가 internal 접근 제한을 강제합니다")
}

Go code

package main

import "fmt"

// 제네릭 함수
func Map[T, U any](slice []T, fn func(T) U) []U {
	result := make([]U, len(slice))
	for i, v := range slice {
		result[i] = fn(v)
	}
	return result
}

// 제네릭 구조체
type Stack[T any] struct {
	items []T
}

func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
func (s *Stack[T]) Pop() (T, bool) {
	if len(s.items) == 0 {
		var zero T
		return zero, false
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, true
}

func main() {
	nums := Map([]int{1, 2, 3}, func(n int) string {
		return fmt.Sprintf("#%d", n)
	})
	fmt.Println(nums) // [#1 #2 #3]

	s := &Stack[int]{}
	s.Push(10)
	s.Push(20)
	v, _ := s.Pop()
	fmt.Println(v) // 20
}

Go code

package main

import (
	"fmt"
	"golang.org/x/exp/constraints"
)

// 커스텀 제약 정의
type Number interface {
	~int | ~int64 | ~float64
}

func Sum[T Number](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

// constraints.Ordered 사용
func Max[T constraints.Ordered](a, b T) T {
	if a > b {
		return a
	}
	return b
}

type Score int // ~int 덕분에 사용 가능

func main() {
	fmt.Println(Sum([]int{1, 2, 3}))        // 6
	fmt.Println(Sum([]float64{1.1, 2.2}))   // 3.3
	fmt.Println(Sum([]Score{10, 20, 30}))    // 60
	fmt.Println(Max("apple", "banana"))      // banana
}

Go code

package main

import "fmt"

// comparable: ==, != 연산 가능한 타입
func Index[T comparable](slice []T, target T) int {
	for i, v := range slice {
		if v == target {
			return i
		}
	}
	return -1
}

// 맵 키로 사용
type Set[T comparable] map[T]struct{}

func NewSet[T comparable](items ...T) Set[T] {
	s := make(Set[T])
	for _, item := range items {
		s[item] = struct{}{}
	}
	return s
}

func (s Set[T]) Has(item T) bool {
	_, ok := s[item]
	return ok
}

func main() {
	fmt.Println(Index([]string{"a", "b", "c"}, "b")) // 1

	fruits := NewSet("apple", "banana", "cherry")
	fmt.Println(fruits.Has("banana")) // true
	fmt.Println(fruits.Has("grape"))  // false
}

Go code

package main

import "fmt"

func Filter[T any](slice []T, pred func(T) bool) []T {
	var result []T
	for _, v := range slice {
		if pred(v) {
			result = append(result, v)
		}
	}
	return result
}

func Zip[A, B any](a []A, b []B) []struct{ First A; Second B } {
	n := len(a)
	if len(b) < n { n = len(b) }
	result := make([]struct{ First A; Second B }, n)
	for i := 0; i < n; i++ {
		result[i] = struct{ First A; Second B }{a[i], b[i]}
	}
	return result
}

func main() {
	// 타입 추론: [int] 생략 가능
	evens := Filter([]int{1, 2, 3, 4, 5}, func(n int) bool {
		return n%2 == 0
	})
	fmt.Println(evens) // [2 4]

	pairs := Zip([]string{"a", "b"}, []int{1, 2})
	fmt.Println(pairs)
}

Go code

package main

import (
	"fmt"
	// 사이드 이펙트 import 예시:
	// _ "github.com/lib/pq"             // PostgreSQL 드라이버 등록
	// _ "image/png"                       // PNG 디코더 등록
	// _ "net/http/pprof"                  // pprof 핸들러 등록
)

// 별칭 import
// import (
//     chi "github.com/go-chi/chi/v5"   // 별칭
//     . "math"                          // 도트 import (비권장)
// )

func main() {
	fmt.Println("사이드 이펙트 import: init()만 실행")
	fmt.Println("  _ "database/sql/driver" → 드라이버 등록")
	fmt.Println("  _ "image/png"           → 포맷 등록")
	fmt.Println("  _ "net/http/pprof"      → 프로파일링")
}

Go code

package main

import (
	"fmt"
	"strings"
)

// 메서드 제약 인터페이스
type Stringer interface {
	String() string
}

type Validator interface {
	Validate() error
}

// 두 제약을 합성
type ValidStringer interface {
	Stringer
	Validator
}

func PrintValid[T ValidStringer](items []T) {
	for _, item := range items {
		if err := item.Validate(); err != nil {
			fmt.Printf("INVALID: %v\n", err)
			continue
		}
		fmt.Println(item.String())
	}
}

type Email string
func (e Email) String() string    { return string(e) }
func (e Email) Validate() error {
	if !strings.Contains(string(e), "@") {
		return fmt.Errorf("유효하지 않은 이메일: %s", e)
	}
	return nil
}

func main() {
	emails := []Email{"user@go.dev", "invalid", "admin@go.dev"}
	PrintValid(emails)
}