[Go] Modern Go 기본

 

들어가며

Go의 기본 사용법에 대해서 알아보겠습니다. 프로그래밍 기초 문법에 대해서 다루지는 않습니다. 타 언어와 비교했을 때 어떤 편리한 점과 차이가 있는지 간단히 짚어보겠습니다.

 

변수

• 정수 타입: int8/16/32/64, uint8/16/32/64, int, uint, rune
• rune: UTF-8인코딩의 유니코드 코드 포인트를 표시하는 정수
• 기본값: 정수 0, 실수 0.0, 불리언 false, 문자열 “”, 그외 nil
• 암시적 타입변환 허용X
• 실수 비교시 math.Nexafter로 비교하면 편리
• a, b = b, a 스왑
• iota로 열거값 사용

const (
  Red    int = iota  // 0
  Blue   int = iota  // 1
  Green  int = iota  // 2
  Yellow int = iota + 1  // 3 + 1 = 4
)

• 네이밍 컨벤션
  • Go 언어에서는 대문자로 시작하는 식별자만 외부 패키지에서 접근 가능

 

조건문(if, switch)

• if 초기문; 조건문

if filename, success := UploadFile(); success {
  ...
}

• switch에 들어가는 인자에는 문자열도 허용(case “monday”:)
• case에서 break 명시 안해줘도 알아서 됨
• switch에 조건 비교가 다양

switch true {   // true 생략 가능
  case temp < 10, temp > 30:
    fmt.println("바깥 활동하기 좋은 날씨가 아님")
  case humidity > 50:
	  fmt.println("습도가 너무 높음")
}

switch age := getMyAge(); age {
  case 10:
    fmt.println("Teenage")
  ...

 

반복문(for)

• 직관성을 위해 while 지원하지 않음
• for { … } 는 무한 루프(while true 대체)
• range 사용 반복(사용 빈도 높음)

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

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

 

구조체

• 포함된 필드(구조체 안에 포함된 다른 구조체의 필드명 생략)

type User struct {
  Name string
  ID string
}

type VIPInfo struct {
  User       // 필드명 생략
  Level int
  Price int
}

vip := VIPInfo{ User{ "박지상", "jisang"}, 3, 250 }
fmt.Printf("Name of VIP: %v", vip.Name) // 구조체 안에 포함된 다른 구조체의 필드명 생략

 

포인터

• 포인터 연산(+, -) 불가
• 기본적으로 GC 지원
• new 사용

p1 := &Data{3, 4}   // Data 인스턴스 생성 및 p1 포인터 참조, 매개변수 초기화 가능
var p2 = new(Data)  // new 키워드 사용, 매개변수 초기화 불가능

 

용어	설명
&	변수의 주소를 가져옴 (address-of operator)
*	포인터가 가리키는 값을 읽음/변경 (dereference operator)
*T	타입 T에 대한 포인터

 

패키지

• fmt 패키지(formatted I/O)
  • fmt::Print(), fmt::Println(), fmt::Printf()
  • 형식 지정자 %v: 자동 타입 추론, %T: 데이터 타입 출력, %t: 불리언을 true/false로 출력
• 패키지 별칭

import (
  "text/template"
  "html/template"  // 같은 이름의 패키지
 )
 
 
 import (
  "text/template"
  htemplate "html/template"  // 별칭: htemplate
 )
 
template.New("foo").Parse(`{{define "T"}}Hello`)
htemplate.New("foo").Parse(`{{define "T"}}Hello`)

• Go 모듈
  • Go 패키지를 모아놓은 Go 프로젝트 단위
  • Go 1.16버전부터 Go 모듈 사용이 기본이 됐음(모든 Go 코드는 Go 모듈 아래 있어야 함)
  • go.mod 파일을 통해 Go 버전, 필요한 외부 패키지 명시
  • go mod init(초기화), go mod tidy(패키지 다운로드)
  • go.sum파일: 패키지 위조 여부를 검사하기 위한 체크섬(checksum) 결과
• 패키지 외부 공개
  • 패키지 전역으로 선언된 첫 글자가 대문자로 시작되는 모든 변수, 상수, 타입, 함수는 외부로 공개
• 패키지 초기화
  • 패키지를 임포트하면 컴파일러는 패키지 내 전역변수를 초기화 함
  • 패키지에 init() 함수가 있다면 호출해 패키지를 초기화
  • init()함수는 반드시 입력 매개변수가 없고 반환값도 없는 함수여야 함

💡 패키지 A가 다른 패키지 B를 import하는 경우:
패키지 B의 전역 변수 선언 → init() 호출그 다음에 패키지 A의 전역 변수 선언 → init() 호출
즉, 의존성이 깊은 쪽이 먼저 초기화됨.

// 예시

// a.go
package a

import "fmt"

var A = initA()

func initA() int {
    fmt.Println("a.go: 전역 변수 A 초기화")
    return 1
}

func init() {
    fmt.Println("a.go: init 함수 호출")
}

// main.go
package main

import (
    "fmt"
    _ "yourmodule/a" // 강제 import (init 실행만 원할 때)(밑줄 _을 이용해서 init() 함수만 호출)
)

func main() {
    fmt.Println("main 실행")
}

a.go: 전역 변수 A 초기화
a.go: init 함수 호출
main 실행

 

문자열

• 기본
  • 문자열은 기본적으로 불변 → 문자열은 불변이고 값 타입이므로 함수 인자로 넘기면 복사됨
• 문자열 순회

// byte 단위 순회
for i := 0; i < len(s); i++ {
    fmt.Printf("%c ", s[i])  // 한글 등 유니코드 깨짐
}

// rune 단위 순회(정상 한글처리)
for i, r := range s {
    fmt.Printf("index: %d, rune: %c\\n", i, r)
}

• 문자열 주요 함수(strings 패키기)

import "strings"

strings.HasPrefix(s, "pre")   // 접두사 확인
strings.HasSuffix(s, "fix")   // 접미사 확인
strings.Contains(s, "lo")     // 포함 여부
strings.ToUpper(s)            // 대문자 변환
strings.ToLower(s)            // 소문자 변환
strings.TrimSpace(s)          // 공백 제거
strings.Split(s, ",")         // 문자열 분할
strings.Join([]string{"a", "b"}, "-") // "a-b"