Go 기본 문법에 대해서 알아보자

개요

• go 언어 사용법에 대해서 알아보자
• 다음 목차로 진행되며 다른 언어로 프로그래밍을 경험해본 사람 대상으로 작성한다
  • 개요
  • 변수, 상수 선언(+축약형 선언)
  • 타입
  • 함수 선언(ignore value(_), defer, export function)
  • 조건문(if, switch)
  • 반복문(for)
  • pointer(*)
  • 배열(slice, array)

변수, 상수 선언

• 기본적으로 상수는 const, 변수는 var 키워드를 이용해 선언한다
• 여러 방법으로 변수, 상수 선언도 가능한데, 이는 아래 코드로 살펴보자

// 기본 선언
var age = 23

var name string
name = "mokhs"

// 변수 축약형 선언 : 아래서 자세히 알아보자
role := "Backend Engineer"

// 상수 선언
const minAge = 0

fmt.Println(age, name, role, minAge)

축약형 선언

• go 에서는 name := "mokhs00"와 같이 축약형 선언이 가능하다
• 대입하는 값으로 타입이 추론되어 자동으로 적용된다.
• 이는 함수 내부에서만 사용할 수 있고, 함수 외부에서는 사용이 불가능하니 주의하자

// error
count := 1

func main() {
  count := 1

  fmt.Println(count)
}

타입

• go에는 타입이 존재하고 공식문서에서도 확인 가능하다

var Typ = []*Basic{
  Invalid: {Invalid, 0, "invalid type"},

  Bool:          {Bool, IsBoolean, "bool"},
  Int:           {Int, IsInteger, "int"},
  Int8:          {Int8, IsInteger, "int8"},
  Int16:         {Int16, IsInteger, "int16"},
  Int32:         {Int32, IsInteger, "int32"},
  Int64:         {Int64, IsInteger, "int64"},
  Uint:          {Uint, IsInteger | IsUnsigned, "uint"},
  Uint8:         {Uint8, IsInteger | IsUnsigned, "uint8"},
  Uint16:        {Uint16, IsInteger | IsUnsigned, "uint16"},
  Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32"},
  Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64"},
  Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr"},
  Float32:       {Float32, IsFloat, "float32"},
  Float64:       {Float64, IsFloat, "float64"},
  Complex64:     {Complex64, IsComplex, "complex64"},
  Complex128:    {Complex128, IsComplex, "complex128"},
  String:        {String, IsString, "string"},
  UnsafePointer: {UnsafePointer, 0, "Pointer"},

  UntypedBool:    {UntypedBool, IsBoolean | IsUntyped, "untyped bool"},
  UntypedInt:     {UntypedInt, IsInteger | IsUntyped, "untyped int"},
  UntypedRune:    {UntypedRune, IsInteger | IsUntyped, "untyped rune"},
  UntypedFloat:   {UntypedFloat, IsFloat | IsUntyped, "untyped float"},
  UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"},
  UntypedString:  {UntypedString, IsString | IsUntyped, "untyped string"},
  UntypedNil:     {UntypedNil, IsUntyped, "untyped nil"},
}

함수 선언

• 함수 선언은 func 키워드를 사용하여 선언한다
• 값을 여러개 return 하거나 여러개 타입을 한 번에 선언하는 등의 방식도 가능하다 이는 아래서 알아보자

// 함수 선언기본 형식

/*
func 함수명(인자) 반환타입 {
  return 반환타입과 일치하는 리턴값
}
*/

func foo(value int) int {
  return value
}

// 인자 여러개 받기
func foo(value ...int) []int {
  return value
}

// 여러 값 return
func foo(value int) (int, string) {
  return value, "SUCCESS"
}

// naked return : return 값을 미리 선언할 수 있음
func foo() (value int, message string) {
  value = 1
  message = "SUCCESS"
  return
}

ignore value(_)

• 반환값을 변수로 선언해야 하지만, _를 이용 해당 반환값을 무시할 수 있다
• 참고로 _는 키워드로 취급되어 변수처럼 사용하는 것은 불가능하다
• 다음 예시를 통해 알아보자

func main() {
  _, b := foo()
}

func foo() (int, int) {
  return 1, 2
}

defer

• defer를 이용해 함수 종료 시에 실행할 구문을 추가할 수 있다
• defer로 여러 개의 구문을 추가 시에 위에서부터 아래로 후입선출(LIFO)방식으로 실행된다

func foo() (int, int) {
  defer fmt.Println("isFinished")
  return 1, 2
}

export function

• 함수를 export 하고 싶다면 함수의 첫 글자는 대문자로 작성해야한다
• go의 built-in package의 함수들에서 첫 글자가 대문자인 것을 발견할 수 있는데 이는 같은 이유이다

조건문(if, switch)

• if, switch 키워드를 이용한 조건문 작성이 가능하다
• 다른 언어들과 유사하며, 차이점이 있다면 조건문 선언과 동시에 해당 조건문 안에서만 사용할 수 있는 변수를 선언할 수 있다
• 아래 예시를 통해 알아보자

// if
func canIView(age int) bool {
  // if문 안에서 사용할 변수(koreanAge) 선언
  if koreanAge := age + 2; koreanAge < 18 {
    return false
  }
  return true
}

// switch
func canIView2(age int) bool {

  switch koreanAge := age + 2; {
  case koreanAge < 18:
    return false
  default:
    return true
  }
}

switch, fallthrough

• go의 switch는 case마다 break문의 여부에 따라 연산이 종료되는 다른 언어와는 다르게 break문이 없어도 case의 조건과 일치한다면 switch 연산을 빠져나오게 된다
• 이는 go 컴파일러가 자동으로 case마다 break문을 추가해주기 때문이다
• break하고 싶지 않다면 다음과 같이 fallthrough 키워드를 이용해 break하지 않고 아래 case로 내려줄 수 있다
• 이 때 주의할 점은 아래 case에 일치하는지 여부와 상관없이 case 안의 연산을 모두 수행한다는 점이다

func main() {
  v := 1
  switch v {
  case 1:
    fmt.Println("1")
    fallthrough
  case 2: // 2와 일치하지 않지만 fallthrough에 의해서 case 와 일치할 때와 동일한 연산 수행
    fmt.Println("2")
    fallthrough
  default:
    fmt.Println("default")
  }

  /* 출력
  1
  2
  default
  */
}

반복문(for)

• 다른 언어에서 반복문을 사용할 때 for, while의 키워드가 존재하지만
• go에서 반복문은 for만 존재하고 for만으로 while의 기능도 가능하다
• 또한 조건문에서와 동일하게 반복문 안에서만 사용할 변수를 선언할 수 있다
• range를 이용하면 연속적인 값을 가지는 변수를 순회할 수 있다
• 자세한 건 아래 예시를 통해 알아보자

// 기본 for문
func main() {
  for i:=0; i < 10; i++ {
    // ...
  }
}

// range를 이용한 반복문
func addAll(numbers ...int) int {
  total := 0

  // range를 이용한 numbers 순회 numbers의 타입은 []int
  for _, v := range numbers {
    total += v
  }

  return total
}

pointer

• C와 동일하게 포인터(pointer) 사용이 가능하다
• 포인터란 해당 변수의 주소값을 가리키는 값을 의미하고 주소값을 기반으로 참조를 이용하여 필요에 따라 다양한 로직을 적용할 수 있다
• 주소값을 의미하는 &, 해당 주소에 있는 value를 의미하는 *키워드를 이용한다
• 자세한 건 아래 예시를 통해서 알아보자

func main() {
  a := 2
  // b에 a의 주소값을 저장
  b := &a
  a = 10
  // 0xc00006ef60 0xc00006ef60
  println(&a, b)
  // *키워드로 주소에 저장된 value 조회
  // 10 10
  println(a, *b)
}

배열(slice, array)

• go는 배열을 나타내는 built-in 자료형으로 slice, array를 제공한다
• slice와 array의 차이점은 용량(배열의 크기)를 지정하는 것인데, array는 고정 크기, slice는 유동적인 크기를 가지며, 선언방법도 다르다
  (+ slice는 내부적으로 배열 pointer,length, capacity 값을 가진다)
• 슬라이싱, 요소 추가(append), 복사(copy)길이 측정(length), 용량 측정(capacity) 등이 가능하다
• 아래 예시를 통해서 자세히 알아보자

func main() {
  slice := []int{1, 2, 3}
  array := [5]int{1, 2, 3}

  // [1 2 3] [1 2 3 0 0]
  fmt.Println(slice, array)

  // built-in 함수인 append()를 이용한 요소 추가, slice에만 가능하다
  // [1 2 3 3 4 5]
  fmt.Println(append(slice, 3, 4, 5))
  // slice에 다른 slice를 append하는 것도 가능
  // [1 2 3 5 6 7]
  fmt.Println(append(slice, []int{5, 6, 7}...))

  target := []int{0, 0, 0}
  // target := make([]int, len(slice), cap(slice))
  // target 과 slice의 length가 일치하지 않으면 복사되지 않으니 주의!!
  // 3 [1 2 3] [1 2 3]
  fmt.Println(copy(target, slice), target, slice)

  // 기존 slice나 array를 슬라이싱 (파이썬 문법과 유사하다)
  sliceOfArray := array[:2]

  // len : length 길이, cap : capacity 용량
  // [1 2] 2 5
  fmt.Println(sliceOfArray, len(sliceOfArray), cap(sliceOfArray))
}

slice 선언 with make()

• slice에 대해서 좀 더 알아보자
• slice는 go의 built-in function인 make()로도 선언이 가능하다
• make()를 이용하면 slice의 초기화 길이(length), 용량(capacity)를 지정할 수 있다
• length를 0아닌 값으로 지정하면 length 값 만큼 기본 값이 저장되므로 주의! (아래 예시 확인)

func main() {
  // make(type, length, capacity)
  s := make([]int, 5, 10)
  // 5 10 [0 0 0 0 0]
  fmt.Println(len(s), cap(s), s)
}

slice capacity

• 보통 대부분의 언어에서 동적 배열(e.g.slice)은 요소를 추가할 때마다 용량을 동적으로 증가시킨다
• go에서는 지정한 capacity를 초과했을 때 기존 capacity를 2배로 늘린 새로운 배열을 생성해 기존 배열의 요소들을 복사한다
• 즉 위 과정으로 인해서 오버헤드가 발생할 수 있기 때문에 slice의 용량을 적절히 선언해야한다

map

• key, value 형식으로 데이터를 저장할 수 있는 map을 제공한다
• 선언 방법은 아래와 같다

func main() {
  // map[key type][value type]
  fooMap := map[string]string{"key": "value"}

  fmt.Println(fooMap)
}

structs

• go에서는 c의 구조체와 유사한 형태를 지원한다
• 구조체를 선언함으로써 새로운 자료형을 선언할 수 있고, type-safe에도 효과가 있다
• 아래 예시를 통해 알아보자

type user struct {
  name string
  age  int
}

func main() {
  user := user{name: "mokhs00", age: 23}

  fmt.Println(user)
}