Goの使い方

#初めてGoを使ったまとめ
***目標***
標準出力を受け取ってスクリプトを実行することです。
多数のブログを参考させていただきました。ありがとうございます。
最初のチュートリアル
[A Tour Go](https://go-tour-jp.appspot.com/welcome/1)

[go run と go build](http://nununu.hatenablog.jp/entry/2016/09/20/210000)
凄くわかりやすい

AmazonLinuxでの環境準備
簡単なHelloWorld

```
sudo yum install go
vi hoge.go
go run hoge.go

go build hoge.go
./hoge
```

#基本フォーマット
hoge.go

```
package main　　←main関数がエンドポイントにされている
import (　　　　←読み込む必要のあるパッケージを宣言する
	"fmt"
)
func main() {
	fmt.Println("HolleWorld!")
}
```

```
go build [コンパイル後のファイル名] [コンパイルしたいファイル名]
./[コンパイル後のファイル名]
go run hoge.go 自動的にコンパイル・実行をしてくれる
```

#Function
引数と戻り値は後ろに書くので注意が必要
同じ型の場合は最後の一つに省略できる

```
func swap(x, y string) (string, string) {
	return y, x
}
```
#Named return values
戻り値となる変数に名前を付けることができる

```
func split(sum int) (x, y int) {
	x = sum * 4 / 9
	y = sum - x
	return
}
```

##覚書
#Variables
varは変数を宣言します。最後に型を書くことで変数のリストを宣言できます。

```
var c, python, java bool
var i int
```
#Variables with initializers
varでは初期化子を与えることで型の宣言を省くことができる

```
var c, python, java = true, false, "no!
```

#Short variable declarations
varの代わりに:=で暗黙的な型宣言

```
k := 3
```
#Basic types
基本の方

```
bool
string
int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 の別名
rune // int32 の別名
float32 float64
complex64 complex128
var (
fmt.Printf("Type: %T Value: %v\n", z, z)
)
Type: complex128 Value: (2+3i)
```
#Zero values
変数に初期値を与えずに宣言すると、ゼロ値( zero value )が与えられます

```
fmt.Printf("%v\n", f)
```
#Type inference
明示的に型の宣言をしない場合に、変数の右側の値から型推測される
#Constants(定数)
```
const Pi = 3.14
const World = "世界"
```

#Numeric Constants
数値の定数は、高精度な 値 ( values )

```
const (Big = 1 << 100)
```
#For繰り返し処理
初期化と後処理ステートメントの記述は任意です

```
for i := 0; i < 10; i++ {
for ; sum < 1000; {

```
for i := 0; i < 10; i++ {
for ; sum < 1000; {

```
if x < 0 {
```
#If with a short statement
ifステートメントのに簡単なステートメントを書くことができる
ここで宣言された変数はifスコープ内のみ有効(elseブロックでも有効)

```
if v := math.Pow(x, n); v < lim {
```

# Switch
上から下へcaseを評価します。 caseの条件が一致すれば、そこで停止(自動的にbreak)
***Go では選択された case だけを実行してそれに続く全ての case は実行されません***

```
switch os := runtime.GOOS; os {
case "darwin":
	fmt.Println("OS X.")
default:
```
# Defer
defer へ渡した関数の実行を、呼び出し元の関数の終わり(returnする)まで遅延させる

```
defer fmt.Println("world")
```
#Stacking defers
複数ある場合LIFO(last-in-first-out)後入れ先出

#Pointers
ポインタは値のメモリアドレスを指します
変数 T のポインタは、 *T 型で、ゼロ値は nil
& オペレータは、そのオペランド( operand )へのポインタを引き出します

***オペレータは、ポインタの指す先の変数を示します***

```
var p *int　　　　
i := 42　　　　　
p = &i　　　　　// point to i
fmt.Println(*p)　 // read i through the pointer
*p = 21　　　　　// set i through the pointer
```

#Structs
struct (構造体)は、フィールド( field )の集まりです

```
type Vertex struct {
	X int
	Y int
}
```
#Struct Fields
structのフィールドは、ドット( . )を用いてアクセスします

```
v := Vertex{1, 2}
v.X = 4
fmt.Println(v.X)
```
#Pointers to structs
フィールド X を持つstructのポインタ p

```
(*p).X　=　p.X
v := Vertex{1, 2}
p := &v
(*p).X = 1e9
```

#Struct Literals
structリテラルは、フィールドの値を列挙することで新しいstructの初期値の割り当てを示しています

```
v1 = Vertex{1, 2}  // has type Vertex
v2 = Vertex{X: 1}  // Y:0 is implicit
v3 = Vertex{}      // X:0 and Y:0
```
#Arrays
[n]T 型は、型 T の n 個の変数の配列( array )を表します

```
var a [10]int
fmt.Println(a[0], a[1])
```
#Slices
スライスは可変長
コロンで区切られた二つのインデックス low と high の境界を指定することによってスライスが形成されます
a の要素の内 1 から 3 を含むスライスを作ります

```
a[low : high]
a[1:4]
primes := [6]int{2, 3, 5, 7, 11, 13}
var s []int = primes[1:4]
fmt.Println(s)
```
#Slices are like references to arrays
スライスはどんなデータも格納しておらず、単に元の配列の部分列を指し示しています
スライスの要素を変更すると、その元となる配列の対応する要素が変更されます

```
a := names[0:2]
a[0] = "XXX"
fmt.Println(names)
[XXX Paul]
```
#Slice literals
スライスのリテラルは長さのない配列リテラルのようなものです
配列リテラル : [3]bool{true, true, false}
スライス     : []bool{true, true, false}

#Slice defaults
スライスするときは、それらの既定値を代わりに使用することで上限または下限を省略することができます
これらのスライス式は等価です:

```
a[0:10]
a[:10]
a[0:]
a[:]

s := []int{2, 3, 5, 7, 11, 13}
s = s[1:4]    //[3 5 7]
s = s[:2]     //[3 5]
s = s[1:]     //[5]
```
#Slice length and capacity
スライスの長さは、それに含まれる要素の数です。
スライスの容量は、スライスの最初の要素から数えて、元となる配列の要素数です。
スライス s の長さと容量は len(s) と cap(s) という式を使用して得ることができます。

```
fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
s := []int{2, 3, 5, 7, 11, 13}
s = s[:0]		len=0 cap=6 []	        // Slice the slice to give it zero length.
s = s[:4]		len=4 cap=6 [2 3 5 7]	// Extend its length.
s = s[2:]		len=2 cap=4 [5 7]	// Drop its first two values.
```

#Nil slices
スライスのゼロ値は nil です

```
var s []int	//s == nil
```

#Creating a slice with make
スライスは、組み込みの make 関数を使用して作成することができます。 これは、動的サイズの配列を作成する方法

```
a := make([]int, 5)      //a len=5 cap=5 [0 0 0 0 0]
b := make([]int, 0, 5)    //b len=0 cap=5 []
c := b[:2]               //c len=2 cap=5 [0 0]
d := c[2:5]              //d len=3 cap=3 [0 0 0]
```
#Slices of slices 二次元配列
スライスは、他のスライスを含む任意の型を含むことができます。

```
board := [][]string{		// Create a tic-tac-toe board.
	[]string{"_", "_", "_"},
	[]string{"_", "_", "_"},
	[]string{"_", "_", "_"},
}
board[0][0] = "X"　　　// The players take turns.
```