Goの文法を軽く勉強したので、軽くまとめてみる

# はじめに
A Tour of Goで軽く文法の勉強をしたので、ここに記事として少しまとめてみようと思います。



# 構文

### 型定義
JavaやC#等の静的型付け言語は
```
型 <変数> = ...
```
というように　型名から書き始めると思います。

しかし、Goでは
```
<変数>  型
```
と逆になっています。

例えば、int型の変数xを宣言する場合
- C#
```
int x;
```
- Go
```
x int
```

:::note
後ろに`;`がつきません、気をつけてください
:::

### 変数定義
変数を宣言する場合は、先ほどの型宣言に加えて`var`をつける必要があります。
```
var x int
```

:::note
もし具体的な値を設定しなければ、この場合xは０になります。
bool型の場合は、falseになります。
:::

### 定数定義
javascriptと同じように`const`を定義できる。
```
const x int = 1
```

### 関数宣言

関数は以下のように宣言します。
```
func add(x int, y int) int {
	return x + y
}
```
他の関数の違いとしては、型の指定の仕方がJavaとかと違い後ろにあること、関数名の後ろ({の前）に返す値の型を指定していることが、他の関数と違うことだと感じました。

またこの関数は

```
func add(x ,y int) int {
	return x + y
}
```
とも書けるし

返す値に対応する変数名をあらかじめ指定することもできます。

```
func add(x, y int) (add int) {
	add = x + y
	return
}
```
:::note
上のような記述をnakedreturnsと言います。
:::

### 型変換
下のようにすると型を変換することができます。

```
var i int = 1
f := float64(i)//float64型に変換される
```

### 暗黙的な型変換
静的型付けなので、基本的には変数の方を設定しなければ、変数の宣言は出来ませんが、`:=`を使えば型を推測して設定してくれます。
```Go
i:=1//int型になる
```

### for文
for文は以下のように記述します。

```Go
for i := 1; i < 3 ; i++ {
	sum += i
}
```

### while文
Goには、while文はなく、for文で再現します。

```Go
i := 1
	for ; i < 100 ; {
	 i+=i
	}
	fmt.Println(i)
```
下のようにもかけます
```Go
i := 1
for i<100 {
	i += 1
}
fmt.Println(i)
```
>個人的にはこっち派というか多分こっちの方がよくみる？と思います。

:::note
無限ループは下のように条件式を書きません。
```Go
for{
}
```
:::

### if文
ifは下のように記述します。

```Go
i := 1
	
if i == 1 {
    fmt.Println(1)
}
```

:::note
if文の中に条件式を書くこともできます。
```Go
a := 1
b := 2
if v := a+b ; v == 3{
	fmt.Println("yes")
} else {
}
	
```
:::

### switch文
switch文は以下のように書きます。
```Go
	switch i {
	case 0:
		fmt.Println("0")
	case 1:
		fmt.Println("1")
	case 2:
		fmt.Println("2")
	}
}
```

### defer文
defer文で宣言すると、関数の終わりに実行するようにできます。
```Go
func main{
    fmt.Println("hello")
    defer fmt.Println("hi")
    fmt.Println("world")
}
```

実行結果は下のようになります。
```
hello
world
hi
```

deferによって"hi"は関数の最後に実行されています。

:::note
deferで渡した内容はスタックされるので、最後にdeferと宣言した関数が先に呼ばれます。
このことを`last in first out`(lifo)というらしいです。
:::

### ポインタ
C言語をやってない自分はかなり理解に苦しんでいるポインタです。
下のように書きます。

```Go
i = 10
p := &i
fmt.Println(*p)//10
fmt.Println(p)//メモリアドレスが表示される

*p = 12
fmt.Println(i)//12
```

### 構造体
あらゆる型の変数を入れることができるデータ構造の一種です。

```Go
type Person struct{
	name string
	age int
}
```

構造体のフィールドへのアクセスは以下のように行います。
```Go
p := Person{"m", 10} 

fmt.Println(p.name)//name
```

:::note
構造体を変数に入れるときに、{}ではなく()にしないようにしましょう。
:::

構造体の変数を変更するときは、ポインタを使わなければなりません。
```Go
type Person struct{
	name string
	age int
}

func main() {
	p := Person{"m",10}
	pp := &p
	fmt.Println(*pp)//{m 10}
	fmt.Println(pp.name)//m
}
```

### 配列
決まった数の列である配列を宣言するには以下のように記述します。
```Go
var a [2]int
a[0] = 1
fmt.Println(a)
//[1 0]

nums := [4]int{1,2,3,4}
```

### スライス
可変長の配列のことです。配列の部分列であります。以下のように記述します。

```Go
	nums := [4]int{1,2,3,4}//配列
	
	nums2 := nums[1:4]//スライスに
	
	fmt.Println(nums2)
	//[2 3 4]
	
	nums:=[]int{1,2,3,4}//配列とスライスを同時に作成
	
	nums[0:4]
	nums[0:]
	nums[:4]
	nums[:]
```

:::note
スライスの要素を変更すると元の配列の要素も変更されます
:::

スライスの長さはlenで調べることができます。
```Go
len(s)
```

capで元の配列の先頭からスライスの最後の要素までの数を調べることができます。
```Go
cap(s)
```

以下のように以下のようにfor文で色々調べることができます。
```Go
for i, v := range nums //要素番号、要素

for i := range nums //インデックス

for i, _ := range pow//_で捨てる
```

### make関数
make()でスライスを作ることができます。

```Go
a := make([]int,5)
```

### map関数
キーと値を対応させたデータ構造を作成します。いわゆる辞書型ですね。
```Go
	m := map[string]int{}
	
	m["a"] = 1
	
	fmt.Println(m["a"])//1
	
```
:::note
配列やスライスとは違うデータ構造であることに注意してください
:::

make関数で初期容量を決めることができます。要素を追加することもできます。
```Go
m := make(map[string]int,1)

m["a"] = 1
m["b"] = 2//初期容量設定しても動く
```

構造体をリテラル(値）にすることもできます。
```Go
type Vertex struct {
	Lat, Long float64
}

var m = map[string]Vertex{
	"Bell Labs": Vertex{
		40.68433, -74.39967,
	},
	"Google": Vertex{
		37.42202, -122.08408,
	},
}

```

:::note
単純な型名ならリテラルから推測できます。
```Go
var m = map[string]Vertex{
	"Bell Labs": {40.68433, -74.39967},
	"Google":    {37.42202, -122.08408},
}
```
:::

以下のようなコードでキーと値が存在するか確認することができます。
```Go
elem, ok = m[key]
```

### クロージャー
関数の中の関数を宣言した際に、親関数で宣言した変数等を参照できる子関数のことをクロージャーと言います。
>親と子という言い方は少し正しくないかもしれません、上手い言い方が思いつきませんでした。

```Go
func increment(base int)func() int{
	i := base//下のfuncはこの変数を参照できる
	return func() int {
		i = i+1
		return i
	}
}
```

### インターフェース
ここは正直自分もまだ理解できていない内容です。
複数の型に共通するメソッドの集合を定義することができます。(Javaとかのポリモーフィズムにあたります)
```Go
type Get interface{
    GetName() string
}

type Person struct{
    name string
    age int
}

func (p Person) GetName() string{
    return p.name
}

func main(){
    p := Person{"t",1}
    fmt.Println(p.name)//t
    
    var g Get = p
    fmt.Println(g.GetName())//t
}
```

:::note
構造体のフィールドは参照できません
:::

### 型アサーション
インターフェースに対して指定した型の値を取り出すことができます。
```Go
	var i interface{} = "hello"

	s := i.(string)
	fmt.Println(s)//hello

	s, ok := i.(string)
	fmt.Println(s, ok)//hello true

	f, ok := i.(float64)
	fmt.Println(f, ok)// 0 false

	f = i.(float64) // panic
	fmt.Println(f)
```

### 型スイッチ
肩によって処理を変えることができます。
```Go
func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know about type %T!\n", v)
	}
}
```

### Goroutin
Goのランタイムに管理される軽量なスレッドで並行実行できます
```Go
go f(x, y, z)
```

### channels(チャネルズ)
チャネルオペレータの `<- `を用いて値の送受信ができる通り道を作成できます。
```Go
func sum(s []int, c chan int) {
	sum := 0
	for _, v := range s {
		sum += v
	}
	c <- sum // send sum to c
}

func main() {
	s := []int{7, 2, 8, -9, 4, 0}

	c := make(chan int)
	go sum(s[:len(s)/2], c)
	go sum(s[len(s)/2:], c)
	x, y := <-c, <-c // receive from c

	fmt.Println(x, y, x+y)
}
```
チャネルが閉じているか下で確認できます。
```
v, ok := <-ch
```

#### select文
チャネルによって、処理を変えることができます。
```Go
package main

import "fmt"

func fibonacci(c, quit chan int) {
	x, y := 0, 1
	for {
		select {
		case c <- x:
			x, y = y, x+y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)
	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()
	fibonacci(c, quit)
}

```

### sync.Mutex
排他処理を行う時使うインターフェースです。
ゴールーチンでの処理のダブルブッキングを制限できます。
```Go

func (c *SafeCounter) Inc(key string) {
	c.mu.Lock()//他の処理が行われないようにします
	c.v[key]++
	c.mu.Unlock()//解除
}

func (c *SafeCounter) Value(key string) int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.v[key]
}

func main() {
	c := SafeCounter{v: make(map[string]int)}
	for i := 0; i < 1000; i++ {
		go c.Inc("somekey")
	}

	time.Sleep(time.Second)
	fmt.Println(c.Value("somekey"))
}
```


# 最後に
書いていて説明が難しいなと感じるところがいくつかあったので、これから開発をしていきながらGoとはどういう言語なのかはっきりさせていこうと思います。