TOP

Tour of Go をちょっとずつやったメモ

2016-01-05 14:43:23

A Tour of goが長くてどこまでやったかわからなくなるので自分用まとめ

Go言語の基本型

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 の別名

rune // int32 の別名
     // Unicode のコードポイントを表す

float32 float64

complex64 complex128

Goの型変換(Type conversions)

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

fmt.Printf("%T %T %T",i, f, u) // int float64 uint

定数(Constants)

const World = "世界"
fmt.Println("Hello", World) // Hello 世界

for

// 基本
sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

// 条件式以外は省略可(条件式を省略すれば無限ループになる)
sum := 1
for ; sum < 1000; {
    sum += sum
}

// Goでのwhileはforで書ける
sum := 1
for ; sum < 1000; {
    sum += sum
}

if

func pow(x, n, lim float64) float64 {
    // ifの条件式の前には簡単なステートメントを書ける
    if v := math.Pow(x, n); v < lim {
        return v
    }
    return lim
    // return v     // ただし、if-elseのスコープ外では無効(これはundefined: v になる)
}

func main() {
    fmt.Println(
        pow(3, 2, 10),
        pow(3, 3, 20),
    )
}

switch

breakは書かなくても自動でされる。代わりにbreakしたくない場合は、fallthroughを書く

条件文のないswitchは、if-then-else構造をシンプルに表現出来る

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

defer

defer へ渡した関数の実行を、呼び出し元の関数の終わり(returnする)まで遅延させる

defer へ渡した関数は LIFO(last-in-first-out) の順番で実行される

func main() {
    defer fmt.Println("world")

    var lang = "golang"

    defer fmt.Println(lang)

    lang = "ruby"

    fmt.Println("hello")    // hello golang world と出力される
}

Pointers

func main() {
    i, j := 42, 2701

    p := &i
    fmt.Println(*p) // 42
    *p = 21
    fmt.Println(i)  // 21

    p = &j
    *p = *p / 37
    fmt.Println(j)  // 73
}

Structs(構造体)

Structのフィールドには、ドット( . )でアクセスする

type Vertex struct {
    X int
    Y int
}

func main() {
    v := Vertex{1, 2}
    v.X = 4
    fmt.Println(v.X)
}

もしくはポインタでアクセス

type Vertex struct {
    X int
    Y int
}

func main() {
    v := Vertex{1, 2}
    p := &v
    p.X = 1e9
    fmt.Println(v)
}

Struct Literals

読んでて使い所がよくわからなかったけどのちほど調べる

type Vertex struct {
    X, Y int
}

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
)

func main() {
    fmt.Println(v1, p, v2, v3)  // {1 2} &{1 2} {1 0} {0 0}
}

Arrays

func main() {
    var a [2]string
    a[0] = "Hello"
    a[1] = "World"
    fmt.Println(a[0], a[1])     // Hello World
    fmt.Println(a)              // [Hello World]
}

Slices

func main() {
    s := []int{2, 3, 5, 7, 11, 13}
    fmt.Println("s ==", s)      // s == [2 3 5 7 11 13]

    for i := 0; i < len(s); i++ {
        fmt.Printf("s[%d] == %d\n", i, s[i])
    }
}

Slices of Slices

スライスには任意の型を収めることができ、他のスライスを入れることもできる

func main() {
    // Create a tic-tac-toe board.
    game := [][]string{
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
    }

    // The players take turns.
    game[0][0] = "X"
    game[2][2] = "O"
    game[2][0] = "X"
    game[1][0] = "O"
    game[0][2] = "X"

    printBoard(game)
}

func printBoard(s [][]string) {
    for i := 0; i < len(s); i++ {
        fmt.Printf("%s\n", strings.Join(s[i], " "))
    }
}

/*
    X _ X
    O _ _
    X _ O
*/

Slicing slices

s[lo:hi]    // lo から hi-1 までの要素のスライスを返す
s[lo:lo]    // 空のスライスとなる
s[lo:lo+1]  // 1つの要素を持つスライスとなる

s := []int{2, 3, 5, 7, 11, 13}
fmt.Println("s ==", s)
fmt.Println("s[1:4] ==", s[4:4])            // []

// missing low index implies 0
fmt.Println("s[:3] ==", s[:3])              // [2 3 5]

// missing high index implies len(s)
fmt.Println("s[4:] ==", s[4:])              // [11 13]

Making slices

// 長さ5のスライスを生成
a := make([]int, 5)     // [0 0 0 0 0]

// 3番目の引数に、スライスの容量を指定出来る
b := make([]int, 0, 5)  // []

Nil slices

スライスのゼロ値はnil

var z []int
fmt.Println(z, len(z), cap(z))
if z == nil {
    fmt.Println("nil!")
}

Adding elements to a slice

スライスへ新しい要素を追加するには、appendを使用。

var a []int
fmt.Printf("%s", a);

var a []int
fmt.Printf("%d\n",a)        // []
a = append(a, 0)
fmt.Printf("%d\n",a)        // [0]
a = append(a, 2, 3, 4)
fmt.Printf("%d\n",a)        // [0 2 3 4]

Range

rangeは反復毎に2つの変数を返す。1つ目の変数はインデックスで、2つ目の変数は値。(foreach的な感じ)

変数の部分に_(アンダーバー)を指定する事で、値は捨てる事が出来る

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

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

for _, v := range pow {
    fmt.Printf("2[%d] = %d\n", i, v)    // iは捨てているのでエラーになる。(vだけならばエラーにならない)
}

Maps

map[(keyの型)](valueの型)という感じで書く

mapはmakeで作成する必要がある

type Vertex struct {
    Lat, Long float64
}

var m map[string]Vertex

m = make(map[string]Vertex)
m["Bell Labs"] = Vertex{
    40.68433, -74.39967,
}
fmt.Println(m["Bell Labs"])

Map literals

type Vertex struct {
    Lat, Long float64
}

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

fmt.Println(m)  // map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]

mapに渡すトップレベルの型が単純な型である場合、型は省略できる

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

Mutating Maps

// 要素の挿入・更新
m[key] = elem

// 要素の取得
elem = m[key]

// 要素の削除
delete(m, key)

// キーに対する要素が存在するかどうか、2つ目の値で確認出来る(変数okはboolで存在すればtrue)
// mapにkeyが存在しない場合、elemはmapの要素の型のゼロ値になる
elem, ok = m[key]

// elemとokが未宣言であれば、 := で省略できる
elem, ok := m[key]

Function closures

func adder() func(int) int {
    sum := 0
    fmt.Println("adder")
    return func(x int) int {
        sum += x
        return sum
    }
}

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

// adder
// 0
// 1
// 3
// 6
// 10

Methods

Goにはclassのしくみはないが、struct型にMethodを定義出来る((v *Vertex)の部分を「レシーバ」と言う)

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
    v := &Vertex{3, 4}
    fmt.Println(v.Abs())    // 5
}

Interfaces

interface型は、Methodの集まりで定義。

type Abser interface {
    Abs() float64
}

func main() {
    var a Abser
    f := MyFloat(-math.Sqrt2)
    v := Vertex{3, 4}

    a = f  // a MyFloat implements Abser
    a = &v // a *Vertex implements Abser

    // In the following line, v is a Vertex (not *Vertex)
    // and does NOT implement Abser.
    a = v       /* Absは、Vertexではなく*Vertexの定義なので、ここでエラーになる */

    fmt.Println(a.Abs())
}

type MyFloat float64

func (f MyFloat) Abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}

type Vertex struct {
    X, Y float64
}

func (v *Vertex) Abs() float64 {    // ←レシーバを*VertexからVertexに変更するとエラーがでなくなる
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

Stringers

よく使われているinterfaceの1つに、fmtパッケージに定義されているStringerがある

type Stringer interface {
    String() string
}

Stringer インタフェースは、stringとして表現することができる型です。 fmt パッケージ(と、多くのパッケージ)では、変数を文字列で出力するためにこのインタフェースがあることを確認します。

package main

import "fmt"

// 構造体
type Person struct {
    Name string
    Age  int
}

// 構造体にメソッドを実装
func (p Person) String() string {
    return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}

func main() {
    a := Person{"Arthur Dent", 42}
    z := Person{"Zaphod Beeblebrox", 9001}

    fmt.Println(a, z)       // Arthur Dent (42 years) Zaphod Beeblebrox (9001 years)
}

Errors

Go言語では例外という概念はなく、error型という変数が用意されている

package main

import (
    "fmt"
    "time"
)

type MyError struct {
    When time.Time
    What string
}

func (e *MyError) Error() string {
    return fmt.Sprintf("at %v, %s",
        e.When, e.What)
}

func run() error {
    return &MyError{
        time.Now(),
        "it didn't work",
    }
}

func main() {
    if err := run(); err != nil {
        fmt.Println(err)        // at 2009-11-10 23:00:00 +0000 UTC, it didn't work
    }
}

その他

ここからは、実際に触ってみる途上で試してみた事とかのメモ