GoLang Study - A Tour of Go

변수

// 어디든
var i, j int = 1, 2

// 함수 안에서 만
k := 3

타입

*정수 값이 필요할 때 특정 이유가 아니라면 int를 사용

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8의 별칭

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

float32 float64

complex64 complex128

For

// 1)
sum := 0
for i := 0; i < 10; i++ {
  sum += i
}

// 2)
sum := 1
for ; sum < 1000; {
  sum += sum
}

// 3) while과 같음
sum := 1
for sum < 1000 {
  sum += sum
}

// 4) 무한
for {

}

IF

// 1)
if x < 0 {
  fmt.Println("Hi")
}

// 2) 조건문 수행 전에 수행될 짧은 구문 작성 가능
if v := math.Pow(x, n); v < lim{
  fmt.Println(v)
}

// 3) if - else
if x < 0 {}
else {}

Switch

// 1) 
os := true
switch os {	
  case true:	
    fmt.Println("HOHOHO")
  case false:
	fmt.Println("hee2929e929")
  default:
	fmt.Println("gekewqk")
}

// 2)
switch os := runtime.GOOS; os {
	case "darwin":
		fmt.Println("OS X.")
	case "linux":
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.\n", os)
	}

// 3) 조건 없는 Switch = switch true와 동일
switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}

Defer

// 1)  
defer fmt.Println("world")
fmt.Println("hello")

//// 결과
 hello
 world

// 2)
defer switcher(true)
defer switcher(false)
fmt.Println("Hellooo")

func switcher(os bool){
	switch os {
	case true:
		fmt.Println("HOHOHO")
	case false:
		fmt.Println("hee2929e929")
	default:
		fmt.Println("gekewqk")
	}
}

//// 결과
 Hellooo
 hee2929e929
 HOHOHO

// 3) 후입선출
fmt.Println("counting")
for i := 0; i < 10; i++ {
	defer fmt.Println(i)
}
fmt.Println("done")

//// 결과
 counting
 done
 9
 8
 7
 6
 5
 4
 3
 2
 1
 0

Pointers

// 1) 포인터는 현재 자신이 보고 있는 주소를 가리키는 것이지 자신의 주소를 바꾸는 것은 아니다!
i, j := 42, 2701          // i 주소 : 0xc00000a970, j 주소 : 0xc00000a978
var p *int                // p를 int type 포인터로 할당
fmt.Println(p, &p)        
p = &i                    // p값의 바라보는 주소를 i로 변경
fmt.Println(i, j, p, *p, &p)  
*p = 11                   // p값의 직접 접근하여 값 변경
fmt.Println(i, j, p, *p, &p)
p = &j                    // p값의 바라보는 주소를 j로 변경
fmt.Println(i, j, p, *p, &p)
*p = *p + 5               // p값의 직접 접근하여 값 변경
fmt.Println(i, j, p, *p, &p)

//// 결과
//// p 자신의 주소 값은 '0xc000006030'로 동일
<nil> 0xc000006030
42 2701 0xc00000a970 42 0xc000006030
11 2701 0xc00000a970 11 0xc000006030
11 2701 0xc00000a978 2701 0xc000006030
11 2706 0xc00000a978 2706 0xc000006030

// 2) runtime error!
i, j := 42, 2701
var p *int
fmt.Println(*p)

// panic: runtime error: invalid memory address or nil pointer dereference

// 3) nil
i, j := 42, 2701
var p *int
fmt.Println(p)

// 4) pointer 정리
i, j := 42, 2701
var p *int						// p *int => int *p 즉, *p라는 int형 변수를 선언한 것으로 기억하면 편안 

p = &i							// 주소를 변경
fmt.Println(i, j, p, *p, &p)	// 값이 변하진 않음
*p = j							// 값을 변화 시킴
fmt.Println(i, j, p, *p, &p)    // 주소가 변하진 않음

Struct

// 
type Vertex struct {
	X int
	Y int
}
v := Vertex{1, 2}
ps := &v
v3 := XD_hub.Vertex{X: 1}
fmt.Println(v, v.X, v.Y, ps, *ps, ps.Y, ps.X, v3)

//// 결과
{1 2} 1 2 &{1 2} {1 2} 2 1 {1 0}

Arrays

//// Array
var a[2] int
a[1] = 10

b := [4]int {2,1}
fmt.Println(a, b)

//// 결과
[0 10] [2 1 0 0]

// Slices
b := [4]int {2,1}

var ww []int = b[0:2]
fmt.Println(ww)

//// 결과
[2 1]

# Slices are like references to arrays (배열을 참조하는 슬라이스)
b := [4]int {2,1}
var ww []int = b[0:2]
ww[0] = 2000
fmt.Println(b)

//// 결과
[2000 1 0 0]

// Slice literals (슬라이스 리터럴)
r := []int {3,4,5}
var r2 []int = []int {6,2,8}
st := []struct{
	i int
	s string
}{
	{2, "sda"},
	{5, "doooss"},
}
fmt.Println(r, r2, st)

//// 결과
[3 4 5] [6 2 8] [{2 sda} {5 doooss}]

// Slice defaults (슬라이스 기본 값)
s := []int{2, 3, 5, 7, 11, 13}

s = s[1:4]
fmt.Println(s)

s = s[:2]		# s = s[0:2] 와 동일
fmt.Println(s)

s = s[1:]		# s = s[1:2] 와 동일
fmt.Println(s)
	
s = s[:]		# s = s[0:1] 와 동일, 현재 전체
fmt.Println(s)

//// 결과, ** 주의할점! : 슬라이스마다 결과를 다시 반영해서 적용한다.
[3 5 7]
[3 5]
[5]
[5]

// Slice length and capacity (슬라이스의 길이와 용량)
h := []int{2, 3, 5, 7}
h = h[:2]
fmt.Println(h, len(h), cap(h))

h = h[1:3]
fmt.Println(h, len(h), cap(h))  // 슬라이스 첫번째 인수를 늘리면, 용량이 줄어듭니다.
								// h[0:4] -> 4 4  h[0:4] -> 4 4
								// h[1:4] -> 3 3  h[0:3] -> 3 4
								// h[2:4] -> 2 2  h[0:2] -> 2 4

//// 결과, len : 길이, cap : 용량
[2 3] 2 4
[3 5] 2 3

// Nil slices
var s []int
fmt.Println(s, len(s), cap(s))
if s == nil {
	fmt.Println("nil!")
}

//// 결과
[] 0 0
nil!

// Creating a slice with make (make 함수로 슬라이스 만들기)
h := make([]int, 5)
fmt.Println(h)

b := make([]int, 0, 5) // len(b)=0, cap(b)=5 
c := b[:2] 
fmt.Println(c)

//// 결과
[0 0 0 0 0]
[0 0]

// Slices of slices (슬라이스의 슬라이스)
board := [][]string{
	[]string{"-","-","-"},
	[]string{"-","-","-"},
}

board[0][0] = "ㅇ"
board[1][0] = "ㅂ"
board[0][1] = "ㅁ"
board[1][1] = "X"

fmt.Println(board)

//// 결과
[[ㅇ ㅁ -] [ㅂ X -]]

// Appending to a slice (슬라이스에 요소 추가하기)
var s []int
s = append(s, 10)
fmt.Println(s)

// *고정된 배열에는 append 불가
// var eod[2] int
// eod = append(eod, 100) //// error!

//// 결과
[10]