Basics

Package

모든 Go 프로그램은 패키지로 구성되어 있습니다.

관습적으로 패키지의 이름은 import 경로의 마지막 요소와 같습니다.

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	fmt.Println("My favorite number is", rand.Rand("fd"))
}

예를 들어 "math/rand" 패키지는 package rand 문으로 시작하는 파일들로 구성되어있습니다.

import

기존 c, c++ 등에서 header file을 include 하기위해

import "fmt"
import "math"

이러한 방식을 사용하였습니다.
go에선 factored import문을 사용하는 방식을 권장합니다.

import (
	"fmt"
	"math/rand"
)

Export

Go에서는 대문자로 시작하는 이름이 export됩니다.
따라서 package내 함수를선언할 때 대문자로 이름을 선언하지 않으면 해당 패키지를 import 하더라도 해당 함수를 사용할 수 없습니다.

func main() {
	fmt.Println(math.pi)
}

func main() {
	fmt.Println(math.Pi)
}

func

parameter

함수는 0개 이상의 인자를 받을 수 있습니다.

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

두 개 이상의 연속된 이름이 주어진 함수 매개변수가 같은 type일 때 당신은 마지막 매개변수를 제외한 매개변수들의 type을 생략할 수 있습니다.

return

반환 개수
한 함수는 몇 개의 결과든 반환할 수 있습니다.

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

naked return
함수 선언시 func split(sum int) (int, int) 이런 방식으로 반환하는 type을 정할 수 있습니다.
다른 방법으로 naked return이라는 방식이 있으며 반환값에 의미를 설명하기 위해서 이름을 정하는 방식입니다.
인자가 없는 리턴문은 이름이 주어진 반환값을 반환합니다.

func split(sum int) (x, y int) {
	x = sum * 4 / 9
	y = sum - x
	return
}
func main() {
	fmt.Println(split(17))
}

위 방식은 짧은 함수에서 사용해야하며, 긴 함수에서의 사용은 가독성을 떨어트릴 수 있습니다.

variable

선언

var 문은 변수에 대한 목록을 선언하며, 마지막은 type을 나타냅니다.
var 문은 package나 func단에 존재할 수 있습니다.

package main

import "fmt"

var c, python, java bool

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

초기화

변수선언은 한 변수당 하나의 초깃값을 포함할 수 있습니다.
만약초깃값이 존재한다면 type은 생략될 수 있으며, 이 경우 type은 초깃값의 type을 취합니다.

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"
	"reflect"
)
func main() {
	k := 3
	fmt.Println(reflect.TypeOf(k), " : ", k)
}

함수 밖에서는 모든 선언이 키워드(var, func, 기타 등등)로 시작하므로 := 구문은 사용할 수 없습니다.

기본 자료형

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은 보통 32-bit 시스템에서는 32 bit, 64-bit 시스템에서는 64 bit의 길이입니다.

정수값 사용시 크기를 정하거나, unsigned 정수 타입을 사용할 것이 아니라면 int를 사요해야 합니다.

명시적인 초깃값 없이 선언된 변수는 해당 변수 type의 zero value가 주어집니다.
숫자 type에는 0
boolean type에는 false
string에는 "" (빈 문자열)

type

형 변환

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)) + 0.1
	var z uint = uint(f)
	fmt.Println(x, y, z)
}

0.1을 float64에 더했으나 uint형으로 변환되어 5가 출력되었습니다.

func main() {
	var x, y int = 3, 4.0
	var f float64 = 5.1
	fmt.Println(x, y, f)
}

당연하게 5.1이 출력됩니다.

Inference type

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

func main() {
	v := 42 // change me!
	fmt.Printf("v is of type %T\n", v)
	k := v
	fmt.Printf("k is of type %T\n", k)
	f := 3.142 
	fmt.Printf("f is of type %T\n", f)
	g := 0.867 + 0.5i 
	fmt.Printf("g is of type %T\n", g)
}

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

Const

const는 변수처럼 선언되지만 const 키워드와 함께 선언됩니다.

const 변수 선언 가능 값

1. character
2. string
3. bollean
4. number

const는 :=(짧은 변수 선언)를 통해 선언 될 수 없습니다.

숫자형 상수

숫자형 상수는 매우 정확한 값입니다.

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 << 63 - 1

	// 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 + 0.0
}

func needFloat(x float64) float64 {
	return x + 0.1
}

func main() {
	fmt.Println(needInt(Big))
	fmt.Println(needFloat(Small))
	fmt.Println(needFloat(Big))
}

Reference

https://go-tour-ko.appspot.com/basics/1