lemonadern's golang learning history

[lemonadern]

はじめます

気になったところとか、初めて知ったところを中心に残す

[lemonadern]

Named return values

返り値のところに名前をつけることができる
スコープ内でその名前を利用でき、return 時には何も書かなくて良くなる

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

可読性を損なうので、短い関数でのみ利用すべき
利用しなくて良いと思う、こういう書き方があることだけ覚えておく

[lemonadern]

Variables

var statement を利用して宣言する
後ろに型を書いて、複数の同じ型の変数を宣言できる
その後ろに = を書いて、初期化する値を入れることもできる

var a, b, c bool
var i, j int = 1, 2

[lemonadern]

Short variable declarations

関数の中では、 := を使って暗黙的な型宣言ができる

k := 3

[lemonadern]

Zero Values

変数宣言時に初期値を与えなかった場合、zero values で暗黙的に初期化される

• 数値：0
• bool：false
• string：""

[lemonadern]

型変換

型 T と変数vに対して、T(v) とするとv をTにキャストできる

[lemonadern]

定数

const Pi = 3.14

const を利用して宣言する。:=は利用できない

[lemonadern]

For

() は無し、{} は必要

	sum := 0
	for i := 0; i < 11; i++ {
		sum += i
	}

真ん中の statement だけでも記述できる

	sum := 1
	for ; sum < 1000; {
		sum += sum
	}

[lemonadern]

While

	for sum < 1000 {
		sum += sum
	}

セミコロンなしでも書ける
他言語でのwhile 文と等価

[lemonadern]

Forever

	for {
	}

条件式も書かなくても動く
無限ループになる

[lemonadern]

If

() は無し、{} は必要

if x < 0 {
	return "i"
}

[lemonadern]

If with a short statement

if のスコープの中だけで有効な statement を条件式の前に書ける。セミコロンで区切る

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

[lemonadern]

Switch

If のように、そのスコープで有効なstatementを条件式の前に書ける。セミコロンで区切る

	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)
	}

マッチした場合はそこでswitch から抜けるので、Cのようにbrake;は必要ない

[lemonadern]

Switch with no condition

switch に条件式を与えなくても動く
外側の値をcase に利用する
if-then-elseのチェーンを簡単に書ける

	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}

[lemonadern]

defer

defer を利用すると、関数の値を返すのを、呼び出し元の関数が終了するまで遅らせる
複数あるときはスタックに積まれていく

関数の評価自体はコードの順に行われており、返すときだけが遅らせられる

[lemonadern]

Pointer

変数 T のポインタは、 *T 型で、ゼロ値は nil です。

// ポインタ *T
var p *int

// &v で v のポインタ
i := 42
p = &i

// *p で、ポインタpが指す先にある変数
*p = 21 

[lemonadern]

これは "dereferencing" または "indirecting" としてよく知られています。

[lemonadern]

Structs

fieldから成る

type Vertex struct {
	X int
	Y int
}

初期化

v := Vertex{1, 2}

アクセス

v.X = 4

[lemonadern]

Pointers to structs

ポインタを利用して構造体へアクセスできる

v := Vertex{1, 2}
p := &v

このとき、(*p).X または p.X でフィールドにアクセスできる

[lemonadern]

Struct Literals

初期化じにフィールドを指定して初期値を与えることができる。

var (
	v1 = Vertex{1, 2}  // has type Vertex
	v2 = Vertex{X: 1}  // Y:0 is implicit
	v3 = Vertex{}      // X:0 and Y:0
	p  = &Vertex{1, 2} // has type *Vertex
)

[lemonadern]

Array

[n]T 型は、型 T の n 個の変数の配列

var arr [4]int

値を入れて初期化する場合、{}で引数を与える

primes := [6]int{2, 3, 5, 7, 11, 13}

• Go において配列の長さは Array型の一部なので、配列のサイズは固定長である。

[lemonadern]

Nil slices

スライスの Zero Value は nil

var s []int

len : 0, cap : 0

[lemonadern]

Creating a slice with make

make関数を使って、スライスを作ることができる
APIは、

make([]T, len, cap)

[lemonadern]

Slices in slices

slices を入れ子にできる

board := [][]string{
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
	}

[lemonadern]

Appending to a slice

append 関数を使って要素を追加できる

s := append(s, 1)
s := append(s, 1, 2, 3)

append 関数の返り値は、もとのスライスに、与えられた変数群を追加したスライスになる

もし、元の配列 s が、変数群を追加する際に容量が小さい場合は、より大きいサイズの配列を割り当て直します。 その場合、戻り値となるスライスは、新しい割当先を示すようになります。

[lemonadern]

Range

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
	for i, v := range pow {
		fmt.Printf("2**%d = %d\n", i, v)
	}
}

for で range を使える
range はインデックスと、該当要素のコピーを返す

[lemonadern]

Map

key-value の関係
map[KeyType]ValueType で宣言する

var m map[string]string

make で初期化できる

m = make map[string]string

[lemonadern]

要素へのアクセス

m[key]

要素の削除

delete(m, key)

キーアクセスなので、キーが存在しない場合もある
存在するかどうか true/false も受け取ることができる
存在しなかった場合、elem はその型のゼロ値になる

elem, ok = m[key]

var m = map[string]string{"name": "gopher", "age": "unknown"}

name, ok := m["name"]
fmt.Println(name, ok)
// gopher true

sex, ok := m["sex"]
fmt.Println(sex, ok)
//  false
// (空文字) false

[lemonadern]

Function Closures

Go における関数はクロージャ

func adder() func(int) int {
	sum := 0
	return func(x int) int {
		sum += x
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			pos(i),
			neg(-1*i),
		)
	}
}

adder は クロージャを返す
sum に束縛されている

[lemonadern]

Fibonacci with closure

package main

import "fmt"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
	now, next := 0, 1
	return func() int {
		res := now
		now = next
		next = res + next
		return res
	}
}

func main() {
	f := fibonacci()
	for i := 0; i < 10; i++ {
		fmt.Println(f())
	}
}

[lemonadern]

Methods

Go では、型にメソッドを定義できる
reciever 引数を取る

レシーバは、 func キーワードとメソッド名の間に自身の引数リストで表現します。
この例では、 Abs メソッドは v という名前の Vertex 型のレシーバを持つことを意味しています。

type Vertex struct {
	x, y float64
}

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.x*v.x + v.y*v.y)
}

[lemonadern]

メソッドは任意の型に対して宣言できるが、レシーバを伴うメソッドの宣言は、レシーバ型が同じパッケージにある必要がある。

[lemonadern]

Pointer revievers

ポインタレシーバを持つメソッドは、レシーバが指す変数を変更できます。 レシーバ自身を更新することが多いため、変数レシーバよりもポインタレシーバの方が一般的です。

func (v *Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

変数レシーバの場合、操作するのはもとの変数のコピーになる

[lemonadern]

Methods and pointer indirection

メソッドがポインタレシーバのとき、変数かポインタのレシーバとして扱える

var v Vertex
v.Scale(5)  // OK ポインタレシーバが自動的に呼び出される (&v).Scale(5) として解釈される
p := &v
p.Scale(10) // OK

[lemonadern]

メソッドが変数レシーバのとき、変数かポインタのレシーバとして扱える

var v Vertex
fmt.Println(v.Abs()) // OK
p := &v
fmt.Println(p.Abs()) // OK 変数レシーバが自動的に呼び出される (*p).Abs() として解釈される

[lemonadern]

Choosing a value or pointer receiver

一般的には変数レシーバまたはポインタレシーバのどちらかに統一してメソッドを与えるべき

ポインタレシーバを使う理由

• レシーバが指す先の変数を変更するため
• メソッド呼び出しごとの変数のコピーをさけるため

[lemonadern]

Interfaces

メゾッドのシグニチャを与えて定義する

type Abser interface {
	Abs() float64
}

interface は暗黙的に実装する (implemented implicitly)

[lemonadern]

Interface values with nil underlying values

インターフェースの具体的な値が nil のとき、メソッドは nil をレシーバとして呼び出される

func (t *T) M() {
	if t == nil {
		fmt.Println("<nil>")
		return
	}
	fmt.Println(t.S)
}

[lemonadern]

nil インターフェースのメソッドを呼び出すと、ランタイムエラーになる

[lemonadern]

Interface values with nil underlying values

interface{}

空のインターフェース
ゼロ個のメソッドを指定する

空のインターフェースは、未知の型の値を扱うコードで使用されます。 例えば、 fmt.Print は interface{} 型の任意の数の引数を受け取ります。

[lemonadern]

Type assertions

t := i.(T)

この文は、インターフェースの値 i が具体的な型 T を保持し、基になる T の値を変数 t に代入することを主張します。
i が T を保持していない場合、この文は panic を引き起こします。

t, ok := i.(T)

この場合、panic が起きることはない

[lemonadern]

WIP

Interface 全然何もわかっていない、一旦とばす