golang チートシート

自分が学習した内容の記録。少しずつ記述を増やしていく。

[A Tour of Go](http://tour.golang.org/welcome/)
[A Tour of Go(日本語)](http://go-tour-jp.appspot.com/)
を先に読むこと。

以下も、必読である。
[実践Go言語](http://golang.jp/effective_go)
[Goプログラミング言語仕様](http://golang.jp/go_spec)

以降の記述でmain()の定義など冗長な部分は省略する。適宜読み取って補完すること。

## ダウンロード

[Download Go](https://golang.org/dl/)

## Hello World

```go:hello.go
package main
import "fmt"

func main() {
 fmt.Printf("Hello, world.\n")
}
```

コンパイル

```
go build hello.go   # コマンドhelloが作成される
```

実行

```
./hello
Hello, World.
```

コンパイル&実行

```
go run hello.go   // 実行ファイルをtmpディレクトリに生成して実行
Hello, World.
```

## 言語の特徴

|特徴 | 説明 |
|-------|--------|
|コンパイル言語|
|文字の大小|区別する
|式(expression)と文(statement)|区別あり式を要求する場所に文は書けない。|
|メモリ管理|ガーベージコレクション(mark&sweep)|
|else if | else if |
|++, --|あり。ただし後置のみ。文なので式に書けない。|

## バージョン確認

```
go version
```

## コメント

| コメント形式 | コメント範囲 |
|-------------|-------------|
| 行コメント| `//` から改行まで |
| ブロックコメント| `/*` から `*/` まで(ネスト不可) |

## 変数

```
foo
Bar
BAZ
```

先頭が大文字かどうかは意味がある(大文字の場合、パッケージ外にエクスポートされる)

使用されない変数宣言は構文エラーになる。関数の戻り値に使用しない値がある場合は、
"\_" に代入する。単独の "\_"(blank identifier) は変数ではない

```
_, err := foo()
```

```
// 定義

var x int
var x int, y int
var x, y int
var (
  x int
  y int
)

// 初期化子(initializer)
// 初期化子があれば型を省略できる

var x, y int = 1, 2
var x, y = 1, 2

// 関数の中なら := による変数定義もできる
x, y := 1, 2
```

## 定数

character、string、boolean、数値(numeric)のみ(コンパイル時に評価される)

```
const Pi = 3.14
```

括弧()で括られたconst宣言では、最初の式と同じ値が各定数に設定される

```
const (
   A = 1
   B
   C = 2
)
fmt.Println(A) // => 1
fmt.Println(B) // => 1
fmt.Println(C) // => 2
```

### 列挙

const 宣言内で、定数ジェネレータ iota を使うと 0からの列挙値(int型)を生成できる。

```
const (
   _ = iota  // blank identifier を使えば、0 を破棄できる
   A
   B
   C
)
fmt.Println(A) // => 1
fmt.Println(B) // => 2
fmt.Println(C) // => 3
```

const宣言が現れると iota は0にリセットされる。また、定数式毎にiota値はインクリメントされる。

```
const (
   A = iota + iota   // 0 + 0 (同じ式に二回現れても、iotaの値は同じ)
   B                 // 1 + 1
   C                 // 2 + 2
)
fmt.Println(A) // => 0
fmt.Println(B) // => 2
fmt.Println(C) // => 4
```

## 基本型

```
bool
string
int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 の別名
rune // int32 の別名
     // Unicode のコードポイントを表す
float32 float64
complex64 complex128
```

### 変数の型を取得

```go
import "reflect"

fmt.Println(reflect.TypeOf("foo"))  // => string

// 表示だけなら、書式 %T も可
fmt.Printf("%T\n", "foo")  // => string
```

### ゼロ値

初期値を設定しない変数はゼロ値で初期化されている

|型  | 値 |
|----|----|
|bool| false
|整数型| 0
|浮動小数点型| 0.0
|string| ""
|ポインタ、関数、インタフェース、スライス、チャネル、マップ型| nil
|構造体、配列| 各要素がそのゼロ値|

### スコープ

* パッケージ
* ファイル
* ブロック `{}`
* if, for, switch
* switch, select の case節

## リテラル

```
1
070 // 8進数
0x10 // 16進数
1.0
true
false
"foo"
`bar\n`   raw string ("bar\\n"と同じエスケープ文字の効果がない)
[]int{0,1,2}
map[string]int{"a": 1; "b": 2 } 
nil  // ポインタ、関数、インタフェース、スライス、チャネル、マップ型のゼロ値。スライスなら空の値(長さ0,容量 0)
```

### キャスト

```
x := uint8(10)
```

## 配列、スライス

配列は、メモリが割り当てられた固定の領域
スライスは配列の部分参照

```
[n]T  // 型表記: 型Tの配列。長さn
[]T   // 型表記: 型Tの配列を参照できるスライス

var p []int = []int{0,1,2,3} // intの配列を生成しそのスライスを定義

p[2] => 2 // 要素参照

* 配列の範囲外参照はruntime error
* 負の数での参照もruntime error (即値で書けばコンパイルエラー)

len(p) // => 4 // 配列の長さ
cap(p) // => 4 // 配列の容量(capacity)=長さ
```

```
// スライス

a := [4]int{0,1,2,3} // 配列を生成

a[lo: hi]  // 配列またはスライスa の lo から、hi-1までのスライスを返す

以下はいずれも配列と同じ長さのスライスを返し、同じ内容を参照する
a[0:len(p)]
a[0:]
a[:len(p)]
a[:]

// 配列aのインデックスnから長さlenのスライス
a[n: n+len]
```

```
a := [4]int{1,2,3,4}
s := a[0:2]

fmt.Println(s)       // [1 2]
fmt.Println(len(s))  // => 2
fmt.Println(cap(s))  // => 4
// fmt.Println(s[2])    // => lenを超えた参照はcap内でもruntime error

// スライスは元の配列と同じ位置を指している
s[0] = 10
fmt.Println(a) // [10 2 3 4]
fmt.Println(s) // [10 2]

// aに別の配列を代入するとスライスも変わる(配列への代入は全要素のコピー、スライスへの代入は参照先の変更)
a = [4]int{2,4,6,8}
fmt.Println(a) // => [2 4 6 8]
fmt.Println(s) // => [2 4]
```

上記例で、配列型`[4]int`(2箇所)をスライス型`[]int`にすると最後の結果が変わる(`[10 2]`のまま)。ほとんどの場面では上記のような明示的な配列型`[4]int`は使わずにスライス型`[]int`の変数を利用するのがよい。

なお、[...]int{1,2,3,4}と"..."を使えば、長さを明記せずに配列型を書くことができる。(配列の長さを記入したのと同じ)

```
v := [...]int{1,2,3,4}
fmt.Printf("%T\n", v)  // => [4]int
```
```
a := [...]int{1,2,3,4}
s := a[0:3]
fmt.Println(a) // => [1 2 3 4]
fmt.Println(s) // => [1 2 3]

// スライスに要素を追加。cap内なら既存の要素が書き換わる
s = append(s, 5)
fmt.Println(a) // => [1 2 3 5]
fmt.Println(s) // => [1 2 3 5]

// スライスに要素を追加。capを超えると新たな配列が生成される
s = append(s, 6)
fmt.Println(a) // => [1 2 3 5]
fmt.Println(s) // => [1 2 3 5 6]
```

```
// 生成

s := make([]int, 5) // 中身は0で初期化
s := make([]int, 5, 100) capacity 指定(長さ100の配列を生成し、len=5、cap=100のスライスを返す)
cap(s) // => 100
```

```
// 拡張/縮小(re-slicing)

スライス演算で、cap以上の拡張はできない
s = s[:cap(b)]
```

## マップ(map)

他の言語で連想配列やハッシュ、辞書のこと

```
map[K]T   // 型表記: 型Tを値、型Kをキーとするマップ

// 補足: map[K] は、T型であると読める。go では、型表記がC言語のように規則的であり、かつ逆向きのためC言語ほど複雑にならない。
```

```
// 生成

foo := make(map[キーの型]値の型)

foo := map[string]uint32 {
   "a": 1,
   "b": 2,   // 最後の要素に余分なカンマを書ける
}
```

```
// 参照
foo["a"]   // キーがなければ値の型のゼロを返す

// キーの有無確認は、2番目の戻り値で判断する
v, ok := foo["c"]
if ok == true {
  // あり
}
```

```
// 置き換え
bar["b"] = 2
```

```
// 削除
delete(foo, "a")
```

## 演算子

```
// 論理演算子
"||"
"&&"
"!"

// 比較演算子
"==" | "!=" | "<" | "<=" | ">" | ">="

// 算術演算子
"+" | "-" | "*" | "/" | "%"

// ビット演算子
"|" | "^" | "&" | "&^"
"<<" | ">>"

// アドレス演算子
"&" | "*"

// 受信演算子(channelから値を取得)
"<-"
```

## 制御構造

### 分岐

if 文

```go
if i > 0 {

} else if i < 0 {

} else {

}

// else の前で改行するとエラー(以下はNG)
if i > 0 {
}
else {
}

// 変数定義付(スコープはifの条件式とブロックの中のみ)
if i := 0; i > 0 {

} else if i < 0 {

}

```

switch 文

case 節にbreak は不要。逆に次のcaseを実行するには fallthrough を書く。
複数のcaseをまとめるには、`,`で区切る。
case 節の値は任意の式が使える。case 式は上から順に評価される。

```
switch i := 0; i {
case 0:
case 1, 3:
  fallthrough
default:
}

switch の式を省略するとtrueの意味になる。

switch {
case i == 0:
case i == 1 || i == 3:
  fallthrough
default:
}
```

type switch

動的型に対する型による分岐で利用する。
type switch 文では fallthrough は使用できない。

```
// 型 interface{} は、任意の型を受け付ける(後述のinterfaceを参照)
func foo(v interface{}) {
  switch t := v.(type) { // ".(type)" は常にこう書く
  case nil:
     fmt.Printf("nil: %#v %T\n", t, t)
  case bool:
     fmt.Printf("bool: %#v %T\n", t, t)
  case int:
     fmt.Printf("int: %#v %T\n", t, t)
  default:
     fmt.Printf("default: %#v %T\n", t, t)
  }
}

foo(nil)  // => nil: <nil> <nil>
foo(1)    // => int: 1 int
foo("xx") // => default: "xx" string
```

### ループ

```go
// for  ループ
for i:= 0; i < 10; i++ {

}

// foreach ループ
// range キーワードを使う(range はforでのみ使用できる構文)

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

// while ループ
i := 0
for ; i < 10; {

  i++
}

i := 0
for i < 10 {

  i++
}

// 無限ループ

for {

}
```

## 関数

```
func(V)T   // 型表記: 型Tの値を返す、型Vを引数に取る関数
```

```go
func 関数名(引数) 戻り値の型 {
  return x
}
```

複数の戻り値を返すことができる

```go
func 関数名(引数) (string, string) {

  return x, y
}
```

戻り型に変数名を書くと return の引数は不要になる
(return に引数を書いてもよい。その値が返る)

```go
func 関数名(引数) (x, y string) {

  return
}
```

以下のようには書けない(変数の定義が重複しているためエラーになる)

```go
func 関数名(x, y string) (x, y string) {

  return
}
```

## クロージャ

```go
z := 2
foo := func(x, y int) int {
  return x*y*z
}

for i, v := range []int{1,2,3,4} {
  fmt.Printf("%d * %d * %d = %d\n", i, v, z, foo(i, v))
}
```

```go
func foo() func()int {
  z := 1 
  return func() int {    
    z++
    return z
  }
}

func main() {
  bar := foo()
  fmt.Println(bar()) // => 2
  fmt.Println(bar()) // => 3
}
```
## 構造体

```
struct {T}   // 型表記: 型Tの値をメンバーに持つ構造体
```

```go
type 構造体名 struct {
  X, Y int
}
```

```go
// 定義(struct literal)

v := 構造体名{1, 2}
v := 構造体名{x: 1} // y 0
v := 構造体名{}     // x, y => 0
```

```
// メンバ参照

v.X
```

## ポインタ

ポインタは、C言語のそれと同じ変数という入れ物の位置を指す型。オブジェクトに対する参照ではない。アロー演算子(->)はない。

```
p := &v
p.X = 2
fmt.Println(v.X) # => 2
```

関数の引数はポインタ渡しでなければ、値のコピーが渡るので呼び出し元に影響しない

```go
type T struct {
  X int
}

func foo(v T) {
  v.X = 2
}

func main() {
  v := T{1}
  foo(v)
  fmt.Println(v)  // => {1}
}
```

定義を

```
foo(v *T)
```
呼び出しを

```
foo(&v)
```

とすれば、`{2}`が返る

### new (メモリ割り当て)

ゼロ初期化した(zeroed ) T の値をメモリに割り当て、そのポインタを返す

```
var t *T = new(T)
または、
t := new(T)  # t は、Tのポインタ型
```

make() は特殊なメモリ割り当て関数で、参照型であるスライス、マップ、チャネル専用の割り当てに利用する。(内部のデータ構造を割り当てその参照であるスライス、マップ、チャネルを返す)

### メソッド(method)

```
// 定義
func (p *T)foo() int {
    return p.X
}

// 呼び出し(vは、T型)
v.foo()
```

パッケージ外の型や基本型に対して、メソッドを定義できない
基本型をもとに作った型には定義できる

```go
type MYINT int

func (p *MYINT)foo() int {
    return p * 2
}

v := MYINT(1)
v.foo()
```

## interface

メソッド群を規定した型

```
interface {
  Foo() int
  Bar() int
}
```

同じメソッドを持つ型はそのinterfaceを実装していると見なされる

```go
package main
import "fmt"

type I interface {
  Foo() int
}

type T struct {
  X int
}

func (p T) Foo() int { // (p *T)ではだめ
  return p.X
}

func main() {
  var v I
  v = T{1}  // interface I と同じメソッドFoo()を持つので代入可能
  fmt.Println(v.Foo())
}
```

メソッドのレシーバ型がポインタなら、インタフェース型の変数にはアドレスを代入する

```
func (p *T) Foo() int { // (p *T)
  return p.X
}

var v I = &T{1}  // & でポインタを代入する
```
メソッドのレシーバ型が値型の場合は、どちらでもOK

```
func (p T) Foo() int { // (p *T)
  return p.X
}

var v I = T{1}   // 値も可能
var v I = &T{1}  // ポインタも可能
```

すべての型は空のinterface `interface {}` を実装していると見なされる

```
var v interface{}
v = 1  // 何でも代入可能

var n int
n = v  // 逆はNG
```

interface の型名を列挙することでそのinterfaceを参照できる
関節的でも参照をループすることはできない。

```
type I1 interface {
  Foo() int
}

type I2 interface {
  I1           // Foo() int と書いたのと同じ
  Bar() int
}
```


## concurrency

goroutine (`go`)

```
// goroutineを生成し関数foo()を並行に実行する

go foo(x, y, z)

// 無名の関数呼び出しを使えば、関数をあらかじめ作らずに並列処理を書くことができる
go func(x int) {
   fmt.Println(x)
}(1)
```

channel (`chan`)

```
chan T  // 型表記: T型を送受信するチャネル
```

```
// 生成
ch := make(chan int)
ch := make(chan int, 100)  // バッファ数指定

// 送信
ch <- v  //バッファがいっぱいならブロックする
// 受信
v := <- ch // データがなければブロックする
```

```go
func foo(c chan int) { c <- 1 }
func bar(c chan int) { c <- 2 }

c := make(chan int)

go foo(c)
go bar(c)
x, y := <- c, <- c  // x, y は、1, 2 または、2, 1 が返る

// chanは参照型のためポインタ渡しする必要はない
```

チャネルを閉じる

```
close(ch)
```

閉じるのは送り手側が行う

受け側は入力があるか(閉じられているかを)2番目の戻り値で判定する

```
v, ok := <-ch
if ok == true {
  // ある
}
```

入力が閉じられるまでループ

```
for i := range ch {

}
```

例:

```go
func foo(c chan int) {
  for _, v := range []int{1,2,3} {
      fmt.Println(v)
      c <- v
  }
  close(c)
}

c := make(chan int)
go foo(c)
for i := range c {
  fmt.Println(i * 10)
}
// 順番は保証されない
1
10
2
20
3
30
```

```go
// 並列処理の完了待ち合わせを簡単に書くサンプル

package main
import "fmt"

func main() {
  c := make(chan bool)

  go func() {
     // 何か長い処理
     fmt.Println("goroutine")
     c <- true // クロージャなので外側のchannelにアクセス可能
  }()

  // メインの処理

  <- c // 待ち合わせ
  fmt.Println("finish")
} 
```

### select 文

複数のchannelからの受信を同時に待つ。 先にデータが来たchannelのみ処理する。
select実行時に既に複数のデータが届いていたら、いずれかのcaseをランダムに処理する。

default が指定されていたらデータが届いていないときブロックせずにdefaultの処理を実行する

```
select {
case v <- ch1:
  fmt.Println(v)
case v <- ch2:
  fmt.Println(v)
default:
  fmt.Println("nothing")
}
```

<!--
## 高階関数

## ライブラリ

import xxx
import 

パッケージ、名前空間

テスト
-->

## type 文

type は型に別名をつける文。別名の型と元の型は区別される

```go
type X struct {
    X int
}

func foo() struct{int} {
  x := struct {int}{1}
  y := X{1}

  // return y はng、 return x はok
  return y   // cannot use y (type X) as type struct { int } in return argument
}
```

## その他

### 時刻

現在時刻

```go
import "time"

time.Now()
```

### Sleep

```go
import "time"

time.Sleep(ns)  // ns は、ナノ秒
time.Sleep(1*time.Second)  // 1秒スリープ
```

### 文字列操作(Split, Join)

```
import . "strings"

s := []string{"abc", "def", "ghi"}

v := Join(s, ",")
fmt.Printf("%#v\n", v) // => "abc,def,ghi"

x := Split(v, ",")
fmt.Printf("%#v\n", x) // => []string{"abc", "def", "ghi"}

x = SplitN(v, ",", 2)
fmt.Printf("%#v\n", x) // => []string{"abc", "def,ghi"}
```