var x int = 10 | 변수 선언 |
x := 10 | 짧은 선언 |
const Pi = 3.14 | 상수 |
int, int8, int16, int32, int64 | 정수 타입 |
uint, uint8, uint16, uint32, uint64 | 부호 없는 정수 |
float32, float64 | 부동 소수점 |
bool | 불리언 (true/false) |
string | 문자열 타입 |
byte (uint8), rune (int32) | 바이트와 유니코드 |
+ - * / % | 산술 |
== != < > <= >= | 비교 |
&& || ! | 논리 |
& | ^ << >> | 비트 |
&x | x의 주소 |
*p | 포인터 역참조 |
:= | 짧은 변수 선언 |
if cond { } | if 문 |
if x := f(); x > 0 { } | 초기화와 함께 if |
if cond { } else { } | if-else |
for i := 0; i < n; i++ { } | 전통적 for 루프 |
for cond { } | while 스타일 루프 |
for { } | 무한 루프 |
for i, v := range slice { } | 슬라이스 순회 |
for k, v := range map { } | 맵 순회 |
break / continue | 루프 제어 |
switch x { case 1: ... } | switch 문 |
switch { case x > 0: ... } | 표현식 없는 switch |
case 1, 2, 3: | 다중 값 |
default: | 기본 케이스 |
fallthrough | 다음 케이스로 이동 |
switch v := x.(type) { } | 타입 switch |
func name(a int, b int) int { } | 반환이 있는 함수 |
func name(a, b int) (int, error) { } | 다중 반환 |
func name(a ...int) { } | 가변 인자 함수 |
func (x int, y int) (sum int) { } | 명명된 반환 |
fn := func(x int) int { } | 익명 함수 |
defer fn() | 실행 지연 |
return a, b | 다중 값 반환 |
func (s *Struct) Method() { } | 포인터 리시버 |
func (s Struct) Method() { } | 값 리시버 |
s.Method() | 메서드 호출 |
var arr [5]int | 배열 (고정 크기) |
arr := [...]int{1, 2, 3} | 배열 리터럴 |
slice := []int{1, 2, 3} | 슬라이스 리터럴 |
slice := make([]int, len, cap) | 슬라이스 생성 |
slice[1:3] | 슬라이스 슬라이싱 |
append(slice, elem) | 슬라이스에 추가 |
len(slice) / cap(slice) | 길이 / 용량 |
copy(dst, src) | 슬라이스 복사 |
m := make(map[string]int) | 맵 생성 |
m := map[string]int{"a": 1} | 맵 리터럴 |
m[key] = value | 값 설정 |
value := m[key] | 값 가져오기 |
value, ok := m[key] | 존재 확인 |
delete(m, key) | 키 삭제 |
len(m) | 맵 크기 |
type Name struct { field Type } | 구조체 정의 |
s := Name{field: value} | 구조체 리터럴 |
s.field | 필드 접근 |
p := &Name{} | 구조체 포인터 |
type Name struct { Other } | 임베딩된 구조체 |
`json:"name"` | 구조체 태그 |
type Name interface { Method() } | 인터페이스 정의 |
interface{} | 빈 인터페이스 (any) |
any | interface{} 별칭 |
v.(Type) | 타입 단언 |
v, ok := x.(Type) | 안전한 타입 단언 |
switch v := x.(type) { } | 타입 switch |
go func() { }() | 고루틴 시작 |
go functionName() | 고루틴으로 함수 실행 |
runtime.NumGoroutine() | 고루틴 수 가져오기 |
ch := make(chan int) | 버퍼 없는 채널 |
ch := make(chan int, 10) | 버퍼 있는 채널 |
ch <- value | 채널로 전송 |
value := <-ch | 채널에서 수신 |
close(ch) | 채널 닫기 |
for v := range ch { } | 채널 순회 |
v, ok := <-ch | 닫힘 확인 |
chan<- int | 전송 전용 채널 |
<-chan int | 수신 전용 채널 |
select { case <-ch1: ... case ch2 <- v: ... } | select 문 |
default: | 논블로킹 select |
case <-time.After(1 * time.Second): | 타임아웃 |
var wg sync.WaitGroup | WaitGroup |
wg.Add(1) / wg.Done() / wg.Wait() | WaitGroup 메서드 |
var mu sync.Mutex | 뮤텍스 |
mu.Lock() / mu.Unlock() | 잠금/해제 |
var once sync.Once | Once (한 번만 실행) |
if err != nil { return err } | 에러 확인 |
errors.New("message") | 에러 생성 |
fmt.Errorf("msg: %w", err) | 에러 래핑 |
errors.Is(err, target) | 에러 타입 확인 |
errors.As(err, &target) | 에러 추출 |
errors.Unwrap(err) | 에러 언래핑 |
panic("message") | Panic (크래시) |
defer func() { recover() }() | panic에서 복구 |
fmt.Println() / Printf() / Sprintf() | 출력 함수 |
strings.Split() / Join() / Contains() | 문자열 조작 |
strconv.Itoa() / Atoi() | 문자열 변환 |
time.Now() / time.Sleep() | 시간 함수 |
os.Open() / os.Create() / os.Remove() | 파일 연산 |
json.Marshal() / Unmarshal() | JSON 인코딩 |
http.Get() / http.ListenAndServe() | HTTP 클라이언트/서버 |
context.Background() / WithTimeout() | 컨텍스트 처리 |
go run main.go | 프로그램 실행 |
go build | 바이너리 빌드 |
go test | 테스트 실행 |
go mod init module | 모듈 초기화 |
go mod tidy | 의존성 정리 |
go get package | 의존성 추가 |
go fmt | 코드 포맷 |
go vet | 정적 분석 |
:= 사용defer 사용 (파일 닫기, 뮤텍스 해제)go fmt와 go vet 실행