Go事始め (3)

package main
import "fmt"
func main() {
    a := [...]int{1, 2, 3, 4, 5}
    p := a[1:3]
    fmt.Printf("length=%d,capacity=%d\n", len(p), cap(p))
    p = append(p, 6)
    fmt.Printf("length=%d,capacity=%d\n", len(p), cap(p))
    p = append(p, 7, 8, 9)
    fmt.Printf("length=%d,capacity=%d\n", len(p), cap(p))
    p = append(p, 10, 11, 12)
    fmt.Printf("length=%d,capacity=%d\n", len(p), cap(p))
}

上記のコードを実行した出力は下記のようになりました。

length=2,capacity=4
length=3,capacity=4
length=6,capacity=8
length=9,capacity=16

 appendで要素を追加するにしたがってlenの返す値が増加するのは見ての通りなのですが、あるタイミングでcapの返す値が大きくなっているのがわかります。ここで要素数とキャパシティは異なるものであることが理解できます。配列のサイズを表す要素数と配列の末尾に効率的に要素を追加するために予め確保されたメモリ領域のサイズを表すキャパシティという2つの要素があるのです。
上記の実行例ではappendによってキャパシティを超える要素が配列に追加されるタイミングで元のキャパシティの倍の値に拡張されていることがわかります。（内部的にcap=4のメモリ領域から、cap=8のメモリ領域へコピーされていると想定できます）
goのsliceは特に効率を気にしなければガンガンとappendを使用してスクリプト言語の配列のように柔軟な使い方が可能になっています。

package main
import "fmt"
func main() {
    /* len=0, cap=0のslice */
    s1 := []int{}
    for i := 0; i < 10000; i++ {
        s1 = append(s1, i)
    }
    fmt.Printf("cap=%d\n", cap(s1))
    /* len=0, cap=10000のslice */
    s2 := make([]int, 0, 10000)
    for i := 0; i < 10000; i++ {
        s2 = append(s2, i)
    }
    fmt.Printf("cap=%d\n", cap(s2))
}

package main
import "fmt"
func main() {
    ch := make(chan int)　/* バッファサイズ0のchannel */
    ch <- 1
    n := <- ch
    fmt.Printf("%d\n", n)
}

fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
        /home/aiga/src/golang/test/ch1.go:7 +0x54
exit status 2

package main
import "fmt"
func main() {
    ch := make(chan int, 1) /* バッファサイズ1のchannel */
    ch <- 1
    n := <- ch
    fmt.Printf("%d\n", n)
}

package main
import "fmt"
func main() {
    ch := make(chan int)
    n := <- ch /* deadlock! */
    fmt.Printf("%d\n", n)
}

ちょっとした応用ですが、goroutineとchannelを組み合わせることでPythonにおけるgeneratorのような処理も簡単に実現できます。

package main
import "fmt"
func nums(init int) chan int {
    n := init
    yield := make(chan int)
    go func() {
        for {
            yield <- n
            /* A */
            n++
        }
    }()
    return yield
}
func main() {
    generator := nums(100)
    fmt.Printf("num=%d\n", <-generator) // => 100
    fmt.Printf("num=%d\n", <-generator) // => 101
    fmt.Printf("num=%d\n", <-generator) // => 102
}

生成したgoroutineは関数numsの動作を開始してコード内の「A」の位置で停止します。以後「<-generator」のようにchannelから読み出しを行うたびに処理を再開して「A」の位置で停止を繰り返します。
このように協調して動作するコルーチン的な処理方法も簡単に実現できるところがgoの強みになっています。

さてinterfaceの説明に戻ります。
上記でMember型へ定義したgreetメソッドをもつ型を表すinterfaceを作成してみましょう。

package main
import "fmt"
/* interfaceの定義 */
type Greetable interface {
    greet()
}
type Member struct {
    name string
    age int
    message string
}
type MemberEx struct {
    name string
    grade string
}
func (self Member) greet() {
    fmt.Printf("%sです。%s\n", self.name, self.message)
}
func (self MemberEx) greet() {
    fmt.Printf("グレード%sの%sだ。よろしくな!\n", self.grade, self.name)
}
func main() {
    members := []Greetable {
        Member{"まつお", 37, "よろしくお願いします!"},
        MemberEx{"つちだ", "X"},
    }
    for _, m := range members {
        m.greet()
    }
}

サンプルコードではGreetable型のsliceにMemberとMemberExの2つを並べていることで異なる型を共通するinterfaceでまとめることができることを示しています。

panicによる関数の巻き戻しを停止させるには組込み関数recoverを使用します。原則としてrecoverはdeferによって遅延実行させなければ意味を持ちません。

package main
import "fmt"
func main() {
    defer func() {
        err := recover()
        fmt.Printf("%s\n", err)
    }()
    panic("error!")
}

package main
import "fmt"
func main() {
    err := recover() /* => nil */
    fmt.Println(err)
}