[기초] Go 기초 정리 - 1 (import, 함수, 변수, 상수, 자료형)

Tour of Go를 기반으로한 Go의 기본 내용입니다.

 

Import

• 한줄씩 써도되고, 하나로 묶을 수도 있다.(factored import)

package main

import (
  "fmt"
  "math"
)

func main() {
  fmt.Printf("Now you have %g problems.\n", math.Sqrt(7))
}

 

함수

• param에서 변수 이름 뒤에 type이 온다.
• (Go 선언 Syntax 관련 번역)

package main

import "fmt"

func add(x int, y int) int {
  return x + y
}

func main() {
  fmt.Println(add(42, 13))
}

 

• 두 개 이상의 연속된 이름이 주어진 함수 매개변수가 같은 type일 때.

func add(x, y int) int {
  return x + y
}

 

• 복수개의 결과를 반환할 경우

package main

import "fmt"

func swap(x, y string) (string, string) {
  return y, x
}

func main() {
  a, b := swap("hello", "world")
  fmt.Println(a, b)
}

 

package main

import "fmt"

func swap(x, y string) (string, string) {
  return y, x
}

func main() {
  a, _:= swap("hello", "world")
  fmt.Println(a)
}

 

 

이름이 주어진(기명의) 반환 값

• 반환 값의 이름이 정해져야 할 경우는 그 이름이 반환 값의 의미를 설명하는 데에 사용되어야함.
• 인자가 없는 return문은 이름이 주어진 반환 값을 반환. (naked return)
• naked return문은 짧은 함수에서만 사용되어야하고, 그렇지 않으면 가독성이 안좋을 수 있음.

package main

import "fmt"

func split(sum int) (x, y int) {
  x = sum * 4 / 9
  y = sum - x
  return
}

func main() {
  fmt.Println(split(17))
}

 

 

변수

• var 문은 변수에 대한 목록을 선언. 마지막은 type이다.
• var문은 package나 함수 단에 존재할 수 있다.

package main

import "fmt"

var c, python, java bool

func main() {
  var i int
  fmt.Println(i, c, python, java)
}

 

변수 초기화

• 변수 선언은 한 변수 당 하나의 초깃값을 포함할 수 있다.
• 초깃값이 존재한다면, type은 생략 가능.(변수는 초깃값의 type을 취함)

package main

import "fmt"

var i, j int = 1, 2

func main() {
  var c, python, java = true, false, "no!"
  fmt.Println(i, j, c, python, java)
}

 

 

짧은 변수 선언

• 함수 내에서 := 라는 짧은 변수 선언은 암시적 type으로 var 선언 처럼 사용 가능
• 함수 밖은 불가.

package main

import "fmt"

func main() {
  var i, j int = 1, 2
  k := 3
  c, python, java := true, false, "no!"

  fmt.Println(i, j, k, c, python, java)
}

 

 

기본 자료형

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8의 별칭

rune // int32의 별칭
     // 유니코드에서 code point를 의미합니다.

float32 float64

complex64 complex128

• int와 uintptr type은 보통 32bit 시스템에서는 32bit, 64bit 시스템에서는 64bit의 길이.
• 정수 값이 필요할 때에는 특정한 이유로 크기를 정해야하거나 unsigned 정수 type을 사용해야하는게 아니라면 int를 사용해야함.

 

package main

import (
  "fmt"
  "math/cmplx"
)

var (
  ToBe   bool       = false
  MaxInt uint64     = 1<<64 - 1
  z      complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
  fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
  fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
  fmt.Printf("Type: %T Value: %v\n", z, z)
}

 

Zero values

• 명시적인 초깃값 없이 선언된 변수는 그것의 zero value로 초기화됨.
• 숫자 type에는 0
• boolean type에는 false
• string에는 "" (빈 문자열)

 

Type 변환

T(v)는 v라는 값을 T type으로 변환시켜줌.

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

 

간단한 버전

i := 42
f := float64(i)
u := uint(f)

 

• C와 달리 Go는 다른 type의 요소들 간의 할당에는 명시적인 변환을 필요로함.

package main

import (
  "fmt"
  "math"
)

func main() {
  var x, y int = 3, 4
  var f float64 = math.Sqrt(float64(x*x + y*y))
  var z uint = uint(f)
  fmt.Println(x, y, z)
}

 

Inference type

:= 혹은 var = 표현을 이용해 명시적인 type을 정의하지 않고 변수를 선언할 때, 그 변수 type은 오른 편에 있는 값으로부터 유추

• 변수 선언의 오른쪽에 무언가 적힐 때, 새로운 변수는 그것과 같은 type이 됨.

var i int
j := i // j 는 int

 

• 오른편에 type이 정해지지 않은 숫자 상수가 올 때, 새 변수는 그 상수의 정확도에 따라 int 혹은 float64, complex128이 됩니다.

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128

 

상수

• 상수는 변수처럼 선언되지만 const 키워드로 선언.
• 상수는 character 혹은 string, boolean, 숫자 값이 될 수 있음.
• 상수는 := 를 통해 선언 불가.

package main

import "fmt"

const Pi = 3.14

func main() {
	const World = "世界"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("Go rules?", Truth)
}

 

숫자형 상수

• 숫자형 상수는 매우 정확한 값.
• type이 정해지지 않은 상수는 그것의 문맥에서 필요한 type을 취함.

package main

import "fmt"

const (
	// Create a huge number by shifting a 1 bit left 100 places.
	// In other words, the binary number that is 1 followed by 100 zeroes.
	Big = 1 << 100
	// Shift it right again 99 places, so we end up with 1<<1, or 2.
	Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
	return x * 0.1
}

func main() {
	fmt.Println(needInt(Small))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))
	//fmt.Println(needInt(Big))//int는 최대 64-bit 혹은 더 작은 상수 저장 가능.
}