blog.PanicBlanket.com

ファイル入出力の練習に cat コマンドを写経してみた。
まずひとつめ、bufio の ReadString 関数で1行ずつ処理。

package main

import (
    "os"
    "fmt"
    "io"
    "bufio"
)

func cat(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    rd := bufio.NewReader(file)
    for {
        s, err := rd.ReadString('\n')
        if err == io.EOF { break }
        fmt.Print(s)
    }
    file.Close()
}

func main() {
    for _, name := range os.Args[1:] {
        cat(name)
    }
}

^o^ > go build cat.go

^o^ > .\cat cat.go cat2.go
package main

import (
        "os"
        "fmt"
        "io"
        "bufio"
)

func cat(filename string) {
        file, err := os.Open(filename)
        if err != nil {
                fmt.Fprintln(os.Stderr, err)
                os.Exit(1)
        }
        rd := bufio.NewReader(file)
        for {
                s, err := rd.ReadString('\n')
                if err == io.EOF { break }
                fmt.Print(s)
        }
        file.Close()
}

func main() {
        for _, name := range os.Args[1:] {
                cat(name)
        }
}
package main

import (
        "os"
        "fmt"
        "io/ioutil"
)

func cat(filename string) {
        buff, err := ioutil.ReadFile(filename)
        if err != nil {
                fmt.Fprintln(os.Stderr, err)
                os.Exit(1)
        }
        os.Stdout.Write(buff)
}

func main() {
        for _, name := range os.Args[1:] {
                cat(name)
        }
}

もうひとつ、io/ioutil パッケージの ReadFile 関数でファイルまるごと読み込む。

package main

import (
    "os"
    "fmt"
    "io/ioutil"
)

func cat(filename string) {
    buff, err := ioutil.ReadFile(filename)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    os.Stdout.Write(buff)
}

func main() {
    for _, name := range os.Args[1:] {
        cat(name)
    }
}

実行結果はひとつめと同じなので省略。

今日はファイル入出力。
前に書いたように、ファイル入出力にはファイルディスクリプタを使う。ファイルディスクリプタは、os パッケージの Open 関数で取得する。取得したファイルディスクリプタで、ファイルからの入力には Read 関数、出力には Write 関数を使い、終わったら Close する。まあ、普通の手順だよな。
以下、サンプル。testin.txt ファイルから読み込んだ内容を testout.txt ファイルに書き込んでいる。

package main

import (
    "os"
    "fmt"
)

func main() {
    input, err := os.Open("testin.txt")
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        os.Exit(1)
    }
    output, _ := os.Create("testout.txt")
    buff := make([]byte, 256)
    for {
        c, _ := input.Read(buff)
        if c == 0 { break }
        output.Write(buff[:c])
    }
    input.Close()
    output.Close()
}

^o^ > cat testin.txt
Hello, Golang!

^o^ > go run fileio.go

^o^ > cat testout.txt
Hello, Golang!

入出力をバイト単位や行単位で行いたいときには bufio パッケージの関数が便利。リーダーやライターを作ってから、入出力関数を呼び出す。
バイト単位には、ReadByte、WriteByte がいい。

package main

import (
    "os"
    "io"
    "bufio"
)

func main() {
    r := bufio.NewReader(os.Stdin)
    w := bufio.NewWriter(os.Stdout)
    for {
        c, err := r.ReadByte()
        if err == io.EOF { break }
        w.WriteByte(c)
        if c == '\n' { w.Flush() }
    }
    w.Flush()
}

10行目と11行目でリーダーとライターを作って、それを使っている。

^o^ > go build echo1.go

^o^ > echo1.exe < echo1.go
package main

import (
        "os"
        "io"
        "bufio"
)

func main() {
        r := bufio.NewReader(os.Stdin)
        w := bufio.NewWriter(os.Stdout)
        for {
                c, err := r.ReadByte()
                if err == io.EOF { break }
                w.WriteByte(c)
                if c == '\n' { w.Flush() }
        }
        w.Flush()
}

もうひとつ、行単位で処理するには、同じリーダー、ライターの ReadString、WriteString が使える。

package main

import (
    "os"
    "io"
    "bufio"
)

func main() {
    r := bufio.NewReader(os.Stdin)
    w := bufio.NewWriter(os.Stdout)
    for {
        s, err := r.ReadString('\n')
        if err == io.EOF { break }
        w.WriteString(s)
        w.Flush()
    }
}

^o^ > go build echo2.go

^o^ > echo2.exe < echo2.go
package main

import (
        "os"
        "io"
        "bufio"
)

func main() {
        r := bufio.NewReader(os.Stdin)
        w := bufio.NewWriter(os.Stdout)
        for {
                s, err := r.ReadString('\n')
                if err == io.EOF { break }
                w.WriteString(s)
                w.Flush()
        }
}

ファイル入出力はファイルディスクリプタを介して行う。要するにファイルをオープンしてファイルディスクリプタを取得し、使い終わったらクローズする、ってわけだ。
ただし、標準入出力に関しては最初から os パッケージに用意されている。

• os.Stdin: 標準入力
• os.Stdout: 標準出力
• os.Stderr: 標準エラー出力

標準入力から読み込むには os.Stdin.Read 関数、出力するには os.Stdout.Write または os.Stderr.Write 関数を使う。
ちょっと試してみよう。次のプログラムは、標準入力から受け取った文字列をそのまま標準出力に書き出す（ctrl + C で終了）。

package main

import "os"

func main() {
    buff := make([]byte, 256)
    for {
        c, _ := os.Stdin.Read(buff)
        if c == 0 { break }
        os.Stdout.Write(buff[:c])
    }
}

^o^ > go run echo.go
hello
hello

ひとつめの hello がキーボードからの入力で、ふたつめの hello が返ってきた出力だ。

今日は、練習のため二分探索木の写経をする。

cf. 二分探索木 – M.Hiroi’s Home Page お気楽 Go 言語プログラミング入門

package main

import "fmt"

type Item interface {
    Eq(Item) bool
    Less(Item) bool
}

type Node struct {
    item Item
    left, right *Node
}

func newNode(x Item) *Node {
    p := new(Node)
    p.item = x
    return p
}

func searchNode(node *Node, x Item) bool {
    for node != nil {
        switch {
            case x.Eq(node.item): return true
            case x.Less(node.item): node = node.left
            default: node = node.right
        }
    }
    return false
}

func insertNode(node *Node, x Item) *Node {
    switch {
        case node == nil: return newNode(x)
        case x.Eq(node.item): return node
        case x.Less(node.item):
            node.left = insertNode(node.left, x)
        default:
            node.right = insertNode(node.right, x)
    }
    return node
}

func searchMin(node *Node) Item {
    if node.left == nil {
        return node.item
    }
    return searchMin(node.left)
}

func deleteMin(node *Node) *Node {
    if node.left == nil {
        return node.right
    }
    node.left = deleteMin(node.left)
    return node
}

func deleteNode(node *Node, x Item) *Node {
    if node != nil {
        if x.Eq(node.item) {
            if node.left == nil {
                return node.right
            } else if node.right == nil {
                return node.left
            } else {
                node.item = searchMin(node.right)
                node.right = deleteMin(node.right)
            }
        } else if x.Less(node.item) {
            node.left = deleteNode(node.left, x)
        } else {
            node.right = deleteNode(node.right, x)
        }
    }
    return node
}

func foreachNode(f func(Item), node *Node) {
    if node != nil {
        foreachNode(f, node.left)
        f(node.item)
        foreachNode(f, node.right)
    }
}

type Tree struct {
    root *Node
}

func newTree() *Tree {
    return new(Tree)
}

func (t *Tree) searchTree(x Item) bool {
    return searchNode(t.root, x)
}

func (t *Tree) insertTree(x Item) {
    t.root = insertNode(t.root, x)
}

func (t *Tree) deleteTree(x Item) {
    t.root = deleteNode(t.root, x)
}

func (t *Tree) foreachTree(f func(Item)) {
    foreachNode(f, t.root)
}

func (t *Tree) printTree() {
    t.foreachTree(func(x Item) { fmt.Print(x, " ") })
    fmt.Println("")
}

type Int int

func (n Int) Eq(m Item) bool {
    return n == m.(Int)
}

func (n Int) Less(m Item) bool {
    return n < m.(Int)
}

func main() {
    a := newTree()
    for _, v := range []int { 5,6,4,7,3,8,2,9,1,0 } {
        a.insertTree(Int(v))
    }
    a.printTree()
    for i := 0; i < 10; i++ {
        fmt.Println(a.searchTree(Int(i)))
    }
    a.printTree()
    for i := 0; i < 10; i++ {
        a.deleteTree(Int(i)) a.printTree()
    }
}

探索木自体は Item 型（インターフェイス）を対象としている。このため int に Int という別名をつけて Eq と Less の2つのメソッドを定義している。わざわざ別名をつけているのは、通常の（構造体でない）型にはメソッドを定義できないため。

^o^ > go run binarytree.go
0 1 2 3 4 5 6 7 8 9
true
true
true
true
true
true
true
true
true
true
0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
2 3 4 5 6 7 8 9
3 4 5 6 7 8 9
4 5 6 7 8 9
5 6 7 8 9
6 7 8 9
7 8 9
8 9
9

構造体と同じく、インターフェイスも別のインターフェイスに埋め込むことができる。
下の例では、BazI に FooI と BarI を埋め込んでいる。すると、BazI を実装した構造体 Baz では、FooI と BarI のメソッドを、あたかも自分のメソッドのように使えるようになる。

package main

import "fmt"

type Foo struct {
    a int
}

type FooI interface {
    getA() int
}

func (p *Foo) getA() int {
    return p.a
}

type Bar struct {
    b int
}

type BarI interface {
    getB() int
}

func (p *Bar) getB() int {
    return p.b
}

type Baz struct {
    Foo
    Bar
}

type BazI interface {
    FooI
    BarI
}

func main() {
    a := []FooI{
        &Foo{1},
        &Foo{2},
        &Baz{},
    }
    b := []BarI{
        &Bar{10},
        &Bar{20},
        &Baz{},
    }
    c := []BazI{
        &Baz{},
        &Baz{Foo{1}, Bar{2}},
        &Baz{Foo{3}, Bar{4}},
    }
    for i := 0; i < 3; i++ {
        fmt.Println(a[i].getA())
        fmt.Println(b[i].getB())
        fmt.Println(c[i].getA())
        fmt.Println(c[i].getB())
    }
}

^o^ > go run interface_embed.go
1
10
0
0
2
20
1
2
0
0
3
4

データ型の判定は switch 文でもできる。これを型switchという。一般的な書式はこう。

switch v := x.(type) {
    case 型1: 処理
    case 型2: 処理
    ...
    default: 処理
}

一昨日書いた型アサーションと似ているけど、カッコの中には type と書く。すると対応する型の case 節が実行される。

package main

import "fmt"

type Num interface {
    number()
}

type Int int

func (n Int) number() {}

type Real float64

func (n Real) number() {}

func sumOfNum(ary []Num) (Int, Real) {
    var sumi Int = 0
    var sumr Real = 0.0
    for _, x := range ary {
        switch v := x.(type) {
            case Int: sumi += v
            case Real: sumr += v
       }
    }
    return sumi, sumr
}

func main() {
    var ary[]Num = []Num{
        Int(1),
        Real(1.1),
        Int(2),
        Real(2.2),
        Int(3),
        Real(3.3),
    }
    a, b := sumOfNum(ary)
    fmt.Println(a, b)
}

^o^ > go run type_switch.go
6 6.6

空インターフェイスとは、定義すべきメソッドを持たないインターフェイスのことだ。言い換えるとどんな型にも当てはまる。空インターフェイスの配列やスライスはどんな型でも格納することができる。下の例ではスライス a に整数、実数、文字列を格納している。
Go は静的型付け言語なので、スライスに格納されているのが何の型なのかわからないのでは都合が悪い。そこで、型をチェックする機能がある。それが型アサーションだ。型アサーションは「変数.(型)」という書き方をして、変数が型と一致すればその値と true の2つの値が返ってくる。一致しなければゼロ値と false だ。下の例では、この型アサーションを使って、スライスに含まれる整数と実数のそれぞれの合計を求めている。

package main

import "fmt"

func sumOfInt(ary []interface{}) int {
    sum := 0
    for _, x := range ary {
        v, ok := x.(int)
        if ok {
            sum += v
        }
    }
    return sum
}

func sumOfFloat(ary []interface{}) float64 {
    sum := 0.0
    for _, x := range ary {
        v, ok := x.(float64)
        if ok {
            sum += v
        }
    }
    return sum
}

func main() {
    a := []interface{}{ 1, 1.1, "abc", 2, 2.2, "def", 3, 3.3 }
    fmt.Println(sumOfInt(a))
    fmt.Println(sumOfFloat(a))
}

^o^ > go run interface3.go
6
6.6