GO言語基礎②（defer/map/range/Interface/goroutine/channel）

# 前回の記事
[GO言語基礎①（package/function/for/if/switch/struct/point/arrays/slice）](https://qiita.com/kenRp01/items/68e5c59dfafbb777d8dd)
# 基礎文法

## Defer：遅延実行
`defer`へ渡した関数の実行を呼び出し元の関数の終わり(returnする)まで遅延させる。`Finally`のようなもの。
`defer`が複数ある場合、渡した順にスタックされていき、最後から順に実行されていきます。
defer内での処理でエラーが発生した場合、エラーハンドリングのreturnは無視されます。
対策は以下記事を参考にしてください。
[【Go】 deferに渡した関数内のエラーを呼び出し元に返す](https://qiita.com/vengavengavnega/items/fd0782c30574a983b8a5)

``` :宣言方法
defer <処理>
```
下記の順で`defer`に処理が渡されていた場合

```go
	defer func() {
		fmt.Println("処理１")
	}()

	defer func() {
		fmt.Println("処理２")
	}()

	defer fmt.Println("処理３")
```
```:実行結果
処理３
処理２
処理１
```

後勝ちで処理が実行される。
`defer`に渡した関数ないでファイル処理、変換処理等でエラーが発生した場合、エラーを拾うことができない。（関数内で拾うことは可能）
ファイル編集後のファイルを閉じる処理等で利用します。

## Maps：連想配列
`Maps`はキー (key)というデータを使って要素を指定するデータ構造である。
複数の宣言方法が存在する。
初期値を指定しない場合、変数はnil(nil マップ)に初期化される。
要素の挿入や削除が行える。

```:宣言方法
var m map[キーの型]要素の型
var m map[キーの型]要素の型{"key":value,"key":value}
m := make(map[キーの型]要素の型, キャパシティの初期値(省略可能))
```
```go

	// 初期値を指定しない宣言（空のmap値のmakeで生成したときのような追加等できないため、型宣言のみ）
	var m1 map[string]int
	fmt.Println(m1)
	m1 = map[string]int{"Go": 1}
	fmt.Println(m1)

	// 初期化＋予め要素数分のキャパシティの確保ができる
	m2 := make(map[string]int)
	mk := make(map[string]int, 2)
	fmt.Println(m2, mk)

	// 値の追加
	m2["Go"] = 1
	m2["Python"] = 2
	fmt.Println(m2)

	// 削除
	delete(m2, "Python")
	fmt.Println(m2)

	// 初期値を指定して宣言
	m3 := map[string]int{"Go": 1, "JavaScript": 2}
	fmt.Println(m3)
```
```:実行結果
map[]
map[Go:1]
map[] map[]
map[Go:1 Python:2]
map[Go:1]
map[Go:1 JavaScript:2]
```

## Range(forのrange節)
`range`は拡張for文のようなものです。
`map`、`Slices(スライス)`の要素を順に出力できます。
スライスの場合は、**インデックス番号と値の取得**
mapの場合は、**keyとvalueの取得**が可能です。
switch文のように`contenue`、`bleak`にて処理の継続、中断も可能です。

```:宣言方法
// スライスの場合
for インデックス番号, 値 := range スライス
// mapの場合
for key, value := range map
```

```go
	s := []string{"Go", "Python", "Ruby", "Java"}
	m := map[int]string{0: "Go", 2: "Python", 3: "Ruby", 4: "Java"}

	// スライスのrange
	for i, v := range s {
		fmt.Println("スライスの場合:", i, v)
	}
	// mapのrange
	for k, v := range m {
		fmt.Println("mapの場合:", k, v)
	}

	// スライス:indexを取得しない場合
	for _, v := range s {
		fmt.Println(v)
	}
	// map:valueを取得しない場合
	for k, _ := range m {
		fmt.Println(k)
	}

	// 処理の中断、スキップ
	for _, v := range s {
		if "Go" == v {
			fmt.Println("静的言語")
			continue // 次の処理にスキップ
		}
		if "Ruby" == v {
			fmt.Println("動的言語")
			break // ループから抜ける
		}
		fmt.Println("学習中。。")
	}
```
```:実行結果
スライスの場合: 0 Go
スライスの場合: 1 Python
スライスの場合: 2 Ruby
スライスの場合: 3 Java
mapの場合: 2 Python
mapの場合: 3 Ruby
mapの場合: 4 Java
mapの場合: 0 Go
Go
Python
Ruby
Java
0
2
3
4
静的言語
学習中。。
動的言語
```

## Interface

`interface(インターフェース)` とはメソッドの型だけを定義した型のことです。
`interface(インターフェース)`を利用することで、**オブジェクト指向言語でいうところのポリモーフィズムと同様の機能を実現できます。**
前回紹介した`Embedded`を利用したストラクトの継承の際にメソッドの実行漏れを防ぐために利用します。

```:宣言方法
type 型名 interface {
    メソッド名1(引数の型, ...) (返り値の型, ...)
      .....
    メソッド名N(引数の型, ...) (返り値の型, ...)
}
```
### 空のInterface
Go言語には、全ての型と互換性を持っている`interface{}型（空インターフェース）` というものが存在しています。
`interface{}（空インターフェース）`は文字通りゼロ個のメソッドを指定されたインターフェース型のことなので、以下の様に定義する事ができます。

```go
// 空のインターフェース
var obj interface{}

func main() {
	obj = 1
	obj = "string"
	obj = 1.2
	obj = []string{"Go", "Python", "Ruby"}
	obj = map[int]string{1: "Go", 2: "Java"}
	obj = func(val int) string { return fmt.Sprintf("number is %d", val) }
}
```
### 型アサーション
どんな型の値でも受け取れるinterface{}ですが、interface{}型の引数で受け渡された値は、元の型の情報が欠落しています。
Go言語ではこのような局面で利用するための型アサーションを提供しており、型アサーションにより実体の型が何であるかを動的にチェックすることができます。（以下構文を使用します）

```:記述方法
value, ok := <変数>.(<型>)
// 第二引数を省略した型。比較結果が異なる場合はエラーを投げる
value := <変数>.(<型>)
```

`value`には実際に格納されている値。`ok`には型の比較結果が格納されます。
また、第二引数の比較結果を取得しないこともできるのですが、型が異なる場合エラーを投げるようになります。

```go
func main() {
	typeCheck(1)
	typeCheck("stirng")
	typeCheck([]string{"Go", "Python", "Ruby"})
}
func typeCheck(obj interface{}) {
	if value, ok := obj.(int); ok {
		fmt.Printf("parameter is integer. %d\n", value)
	}
	if value, ok := obj.(string); ok {
		fmt.Printf("parameter is string. %s\n", value)
	}
	if value, ok := obj.([]string); ok {
		fmt.Printf("parameter is slice. %s\n", value)
	}
}
```

### 型switch
型アサーションと分岐を組み合わせた処理を手軽に記述するための型switchが提供されています。
型switchを利用すると前述のprintIf関数は以下のように記述できます。

```:宣言方法
swich 比較値 := インタフェース型で定義された値.(type) {
case 型:
     処理
```

```go
func main() {
	obj = 1
	switchCheck(obj)
	obj = "a"
	switchCheck(obj)
	obj = []string{"Go", "Python", "Ruby"}
	switchCheck(obj)
	obj = map[int]string{1: "Go", 2: "Java"}
	switchCheck(obj)
}

func switchCheck(obj interface{}) {
	switch value := obj.(type) {
	case int:
		fmt.Printf("parameter is integer %d\n", value)
	case string:
		fmt.Printf("parameter is string %s\n", value)
	case []string:
		fmt.Printf("parameter is slice %s\n", value)
	default:
		fmt.Printf("parameter is unknow type %v\n", value)
	}
}
```

```:実行結果
parameter is integer 1
parameter is string a
parameter is slice [Go Python Ruby]
parameter is unknow type map[1:Go 2:Java]
```

### 構造体にインターフェースの実装
以下の様に書く事で構造体にインターフェースを実装する事ができます。

```:実装方法
func (引数 構造体名) 関数名(){
     関数の中身
}
```
```go
type People interface {
	getName()
}

type Person struct {
	name string
}

func (per Person) getName() {
	fmt.Println(per.name)
}

func main() {
	per := Person{"Mike"}
	per.getName()
}
```
```:出力結果
Mike
```

`Person`のストラクトに`getName`メソッドを実装して実行することができていることがわかる。

## goroutine(ゴルーチン):並列処理
`goroutine`とはGo言語の処理を平行で行うことができます。
マルチスレッドってやつです。

関数の前に`go`をつけることにより、異なる`goroutine``で実行することができます。

```:実装方法
go 関数名() {
}
```
goは新しいgoroutineを生成して、そのgoroutine内で指定された関数を実行します。
新しいgoroutineは並行に動作するので、関数の実行終了を待つことなく、goのあとに記述されているプログラムを実行します。

### goroutineの終了条件
* 関数の処理終了
* `return`で抜ける
* `runtime.Goexit()`を実行する

現在起動している`goroutine`(ゴルーチン)の数の取得は`runtime.NumGoroutine()`を利用することで行うことができる。

```go
func main() {
     log.Println(runtime.NumGoroutine())
}
```

## goroutine(ゴルーチン)の実装例
まず`goroutine`なしのプログラムを記述し、実行例を記述します。

```go:goroutineなし
func main() {
	fmt.Println("Strat")
	roop(2, "firtst")
	roop(2, "second")
	fmt.Println("Finish")
}

func roop(num int, s string) {
	for i := 0; i <= num; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println(i, s)
	}
}
```
```:実行結果
Strat
0 firtst
1 firtst
2 firtst
0 second
1 second
2 second
Finish
```

単純にforループ処理が1秒ごとに行われ、次のループ処理の表示がされていることがわかります。
次は`goroutine`を利用して`roop`関数の処理を並列実行してみます。

```go:goroutineあり、main待ち時間なし
func main() {
	fmt.Println("Strat")
	go roop(2, "firtst")
	go roop(2, "second")
	fmt.Println("Finish")
}

func roop(num int, s string) {
	for i := 0; i <= num; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println(i, s)
	}
}
```
```:実行結果
Strat
Finish
```

単純に関数処理を行う場合は上記のように`goroutine`の実行結果を待たない状態で`main`処理が終了してしまうため、`roop`関数の処理を行うことができていません。
実行するようにするには`goroutine`の実行が終わるまで`main`の処理を止めておく必要があります。
今回の処理では「0〜3」の3秒が最低でもかかるので`main`処理が4秒後に終えるように修正すれば並列処理を確認できます。

```go:goroutineあり、main待ち時間あり
func main() {
	fmt.Println("Strat")
	go roop(2, "firtst")
	go roop(2, "second")
	time.Sleep(4 * time.Second)
	fmt.Println("Finish")
}

func roop(num int, s string) {
	for i := 0; i <= num; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println(i, s)
	}
}
```
```:実行結果
Strat
0 second
0 firtst
1 firtst
1 second
2 second
2 firtst
Finish
```

上記のように待ち時間を記載することで並列処理を確認することができました。
今回は簡潔な処理であったため、待ち時間を指定して強引に並列処理を確認しましたが、本来であれば`channel`を利用して`goroutine`処理終了後に`main`処理に戻すことができます。

## channel(チャネル):同期処理
`channel`は`main`処理と`goroutine`間の並列処理中のデータのやり取りをする場合、２つ以上の`goroutine`の処理でのデータのやり取りを行う場合に利用されます。
これにより値の交換及び同期を行うことができ、予期せぬ処理結果が起こらないことを保証します。
`channel`は以下の方法にて生成します。

```:宣言方法
make(chan 型)
make(chan 型, バッファサイズ) 
```

`バッファサイズ`はchannelで利用するデータ量を表すものです。これによりやり取りできるデータサイズが決まります。

### channel(チャネル)での値の送受信方法

```:値の送受信
// channelにデータを入れる
ch <- data
// channelからデータを取得する
result := <- ch
```
簡単な例は以下です。

```go
func main() {
	c := make(chan int)
	go sum(c)
	fmt.Println(<-c)

}

func sum(c chan int) {
	sum := 0
	for i := 0; i < 5; i++ {
		sum += i
	}
	c <- sum
}
```
```:実行結果
10
```

計算結果が取得できていることがわかります。

### channelの実装例

上記の記述を踏まえた上で、実装例をみていきましょう。
先程の`goroutine`の例では並列処理中の値を取得して、別の`goroutine`にて並列処理を行うということができませんでした。
`time.Sleep`で`main`処理を継続させて並列処理を確認するのではなく、`channel`を利用して処理の同期を取るように修正しましょう。

```go
func main() {
	c1 := make(chan bool)
	c2 := make(chan bool)

	fmt.Println("Strat")
	go roop(2, "firtst", c1)
	go roop(2, "second", c2)

	<-c1
	<-c2

	fmt.Println("Finish")
}

func roop(num int, s string, c chan bool) {
	for i := 0; i <= num; i++ {
		time.Sleep(1 * time.Second)
		fmt.Println(i, s)
	}
	c <- true
}
```
```:実行結果
Strat
0 firtst
0 second
1 second
1 firtst
2 second
2 firtst
Finish
```

`channel`をroop関数に渡すことで、出力処理が終わったタイミングで`channel`を返却して、`main`処理に`goroutine`の処理が終了したことを同期します。
これにより二つの`goroutine`の並列処理を`main`に同期することで、シングルスレッドではなく、マルチスレッドの処理が行われていることがわかります。


# 参考記事
[【Go】基本文法⑥(インターフェース)](https://qiita.com/k-penguin-sato/items/885a61d819cc431304f5)
[【Go】基本文法⑤(連想配列・ Range)](https://qiita.com/k-penguin-sato/items/a320072fa09502bde3e9)
[【Go】基本文法⑦(並行処理)](https://qiita.com/k-penguin-sato/items/5b09fa89d8d231bcdac8)
[Go言語 - 空インターフェースと型アサーション](https://blog.y-yuki.net/entry/2017/05/08/000000)