Go Language #3 more types - countingmars/countingmars.github.io GitHub Wiki

https://tour.golang.org/moretypes/1

Pointers

Go는 포인터 타입을 제공한다. 포인터는 메모리 주소를 가진 변수이다. T 타입에 대한 포인터 타입은 *T이다. 포인터 타입의 zero value는 nil이다. var p *int

& 연산자로 변수에 대한 포인터 값(메모리 주소)을 알아낼 수 있다.

i := 42
p := &i

포인터 변수를 통해 실제 변수 접근하고자 한다면 * 연산자를 사용해야.

i := 42
p := &i
*p = 21

이를 dereferencing(역참조?) 혹은 indirecting(우회접근?)이라고 한다. C언어와 달리 Go는 포인터 연산을 지원하지 않는다.

Structs

구조체(stuct)는 필드(구조체가 가지는 변수)의 묶음이다.

type Vertex struct {
    X int
    Y int
}
func main() {
    fmt.Println(Vertex{1, 2})
}

. 연산자로 구조체의 필드에 접근가능하다.

v := Vertex{1, 2}
v.X = 3
fmt.Println(v.X)

pointers to structs

포인터 뒤에 숨어있는 변수에 접근하기 위해서는 (*p) 형식으로 써야한다. 따라서 구조체의 필드에 접근하는 방식은 이런 식인데 (*p).X 너무 번거롭기 때문에 p.X로 바로 쓸 수 있게 편의를 봐줬다.

p := &Vertex{1, 2}
fmt.Println(p.X)

Struct Literals

구조체를 생성할 때 마치 json 처럼 접근할 수 있다.

v1 := Vertex{ X: 1, Y: 2 }
v2 := Vertex{ X: 1 } // Y는 int에 대한 zero value가 할당되므로 0이 된다.
V3 := Vertex{} // X, Y 둘다 0이 된다. 

Arrays

int 배열을 만들고 싶으면 이런 식이다.

var a = [10]int

타입 T에 대한 배열은 [n]T라는 의미이다.
또한 배열의 사이즈는 배열의 일부이므로 변경될 수 없다. 하지만 Go는 유용한 기능을 많이 제공해준다고 하니 기대해보자.

var names = [2]string { "john", "mars" }

Slices

Array는 고정된 사이즈를 가지지만, Slice는 동적으로 사이즈되는 배열에 대한 유연한 뷰(view)라고 한다.

var s []int

배열을 선언할 때는 [n]type이지만, 슬라이스를 선언할 때는 []type이다.

primes := [6]int{2, 3, 5, 7, 11, 13}
var s []int = primes[1:4] 

위 코드는 primes 배열의 1번째 요소부터 4번째 요소까지(총 3개) 조회하여 s라는 슬라이스를 생성하고 있다.

Slices are like references to arrays

슬라이스는 배열에 대한 참조일 뿐이다. 따라서 슬라이스의 요소에 접근하여 값을 수정하면, 사실은 뒤에 숨어있는 배열의 값을 수정하게 되는 것이다.

Slice literals

리터럴에 대한 슬라이스도 가능하다.

s := []int{ 1, 2 }

Slice defaults

슬라이스를 만들 때, 인덱스 지정을 생략할 수도 있다.
슬라이스의 첫번째 인자의 디폴트는 0이고, 두번째 인자의 디폴트는 그 배열의 length이다.

array := [5]int { 1, 2, 3, 4, 5 }
slice := array[:5]
slice := array[0:]
slice := array[:]
slice := array[0:5]

위의 표현은 모두 동일한 의미이다.

Slice length and capacity

슬라이스의 length는 슬라이스의 아이템 갯수이다. 슬라이스의 capacity는 슬라이스 뒤에 숨어있는 배열의 아이템 갯수이다. 슬라이스의 length는 len(s)으로 알 수 있고, capacity는 cap(s)으로 알 수 있다.

https://tour.golang.org/moretypes/11
위 예제에서 어떻게 drop이 이루어지냐?

s := []int{2, 3, 5, 7, 11, 13}
s = s[:0] // len(s) = 0, cap(s) = 6
s = s[:4] // len(s) = 4, cap(s) = 6, cap이 6.
s = s[2:] // len(s) = 4, cap(s) = 4, cap이 4! 어떻게 앞의 요소들을 slice 했을 때만 drop 되냐?

nil slices

nil slice는 cap(s), len(s)가 모두 0이고, array에 대한 참조를 가지지 않는다.

var s []int
if s == nil {
    fmt.Println("nil slice!")
}

Creating a slice with make

make 함수로도 slice를 만들 수 있다. 이 방식으로 dynamically-sized 배열을 만들 수 있다.
make 함수는 빈 배열을 만들고, 그 배열을 참조하는 slice를 반환한다.

a := make([]int, 5)  // len = 5 지정
b := make([]int, 0, 5) // len = 0, cap = 5 지정

Slices of slices

slice의 slice는 뭘까? 이차원 slice를 의미한다.

board := [][]string { 
    []string { "_", "_", "_" },
    []string { "_", "_", "_" },
    []string { "_", "_", "_" },
}
board[0][0] = "X"
board[2][2] = "O"
for i := 0; i < len(board); i++ {
    fmt.Println("%s", strings.Join(board[i], " "))
}

Appending to a slice

func append(s []T, vs ...T) []T
slice에 새로운 요소를 추가하고 그 결과 slice를 반환하는 함수이다.

만약 slice가 참조하는 array의 범위를 넘어서면 어떻게 될까? 새로운 array를 만들어서 반환해준다. 편하지?

s = []int { 1, 2, } 
s = append(s, 3)
s = append(s, 4, 5, 6, 7)

Range

for 반복문에서의 range는 map이나 slice를 순회한다.

pow := []int { 1, 2, 4, 8, 16, 32 }
for i, v := range pow {
    fmt.Printf("%d, %d\n", i, v)
}

i는 slice의 인덱스, v는 해당 인덱스의 값이다. (맵이라면 key와 value 겠지?)

만약 value가 불필요하다면 , v를 생략하면 된다.
만약 index가 불필요하다면 _를 사용하면 된다.

for _, v := range pow { ... }

Maps

maps는 key와 value를 연결시켜준다.
map의 zero value는 nil이고, 새로운 요소를 추가할 수 없다.

make함수로 준비된(ready for use) map을 만들 수 있다.

type Vertex struct {
    Lat, Lon float64
} 
var m map[string]Vertex 

func main() {
    m = make(map[string]Vertex)
    m["bell labs"] = Vertex { 40.68433, -74.39967, }
    fmt.Println(m["bell labs"])
}

Map literals

var m map[string]Vertex {
   "bell labs": Vertex { 40.68433, -74.39967 },
   "google": Vertex { 37.42202, -122.08408 }
}

만약 map의 값이 정확한 특정 타입이라면 생략할 수 있다.

var m map[string]Vertex {
   "bell labs": { 40.68433, -74.39967 },
   "google": { 37.42202, -122.08408 }
}

Mutating maps

delete 함수로 요소를 삭제할 수 있다.

m[key] = item
delete(m, key)

조회는 이런 식으로 할 수 있다.

item = m[key]

만약 key에 값이 존재하지 않는다면 zero value가 반환된다. 존재 여부는 두번째 반환값에 boolean 값으로 알 수 있다.

item, ok = m[key]
if ok { fmt.Println(item) }

Function values

함수가 값으로 취급된다는 말의 의미는 함수 자체가 파라미터나 반환값이 될 수 있다는 의미이다.

func compute(fn func(float64, float64) float64) float64 {
    return fn(3, 4)
}
func main() {
    adder := func(a, b float64) float64 {
        return a + b
    } 
    sum := compute(adder)
    fmt.Println(sum)
}

Function closures

function value가 함수 외부의 변수를 참조할 경우, closure가 된다.

func createAdder() func(int) int {
    sum := 0
    return func(v int) int {
        sum += v
        return sum
    }
}
func main() {
    add := createAdder()
    add(1)
    add(3)
}