カテゴリー: Go

関数は変数のスコープを作るので、引数や関数内で宣言された変数はその関数内だけで有効なローカル変数になる。
ほかにも {} でブロックを作ってやると、そのブロックは新しいスコープを作ってブロック内で宣言された変数はブロック内だけで有効になる。例えば、次の例がわかりやすいだろう。

package main

import "fmt"

func main() {
    x := 1
    {
        y := 2
        {
            z := 3
            fmt.Println(x)
            fmt.Println(y)
            fmt.Println(z)
        }
        fmt.Println(x)
        fmt.Println(y)
    // fmt.Println(z) z はスコープ外（コンパイルエラー）
    }
    fmt.Println(x)
    // fmt.Println(y) y はスコープ外（コンパイルエラー）
    // fmt.Println(z) z はスコープ外（コンパイルエラー）
}

注意が必要なのは、if 文なども新しいスコープを作るので、次の例はエラーになってしまう。

package main

import "fmt"

func main() {
    a := 10

    if a > 5 {
        b := "Yes"
    } else {
        b := "No"
    }

    fmt.Println(b)
}

^o^ > go run var_local2.go
# command-line-arguments
.\var_local2.go:14: undefined: b

b を出力しようとしているところで、b が定義されていないと怒られている。これを避けるためには、先に b を宣言しておく。

package main

import "fmt"

func main() {
    a := 10
    var b string

    if a > 5 {
        b = "Yes"
    } else {
        b = "No"
    }

    fmt.Println(b)
}

^o^ > go run var_local3.go
Yes

Go のマップは Ruby でいうハッシュ、Python の辞書、要するに連想配列だ。
マップの宣言、初期化は例を見たほうが早いだろう。次のようにする。

package main

import "fmt"

func main() {
    var a map[string]int
    var b map[string]int = map[string]int{ "foo": 1, "bar": 2 }
    var c = map[string]int{ "hoge": 10, "fuga": 20 }

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

^o^ > go run map.go
map[]
map[foo:1 bar:2]
map[hoge:10 fuga:20]

ここで注意。上の例の変数 a のように宣言だけして初期化をしないと、nilマップというものになる。これは空のマップとは違って、キーの追加とかができない。試してみよう。

package main

import "fmt"

func main() {
    var a map[string]int

    fmt.Println(a)

    a["hoge"] = 100

    fmt.Println(a)
}

^o^ > go run map2.go
map[]
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
        C:/Users/takatoh/Documents/w/learning-go/map2.go:10 +0xa7
exit status 2

この通り、a["hoge"] = 100 のところでエラーを起こしている。なんでこんな仕様になってるんだろ？
で、空のマップがほしい時には make 関数を使う。

package main

import "fmt"

func main() {
    var a = make(map[string]int)

    fmt.Println(a)

    a["foo"] = 10
    a["bar"] = 20

    fmt.Println(a)
}

これなら新しいキー（と値）を追加できる。

^o^ > go run map3.go
map[]
map[foo:10 bar:20]

参照するには [] でキーを指定すればいいけど、返ってくる値は2つある。キーが存在する場合には対応する値と true が、存在しない場合にはゼロ値と false が返ってくる。これはつまり Go には多値があるってことだけど、これについては別の機会に書く。
ともかく、キーが存在するかどうかは2つ目の返り値を見ないとわからないので、ちょっと面倒。
あと、キー（と値）を削除するには delete 関数を使う。

package main

import "fmt"

func main() {
    a := map[string]int{ "foo": 1, "bar": 2 }

    fmt.Println(a)

    value, ok := a["foo"]
    if ok {
        fmt.Println(value)
    }

    a["baz"] = 3
    delete(a, "bar")

    fmt.Println(a)
}

^o^ > go run map4.go
map[foo:1 bar:2]
1
map[baz:3 foo:1]

スライスは make 関数を使っても生成できる。

変数名 := make([]型, 大きさ, 容量)

「大きさ」と「容量」があるけど、「大きさ」は要素の数（ここではゼロ値に初期化される）、「容量」はメモリ上に確保される領域のサイズのこと、と言ったらいいかな。「容量」は省略できる。
「大きさ」、「容量」はそれぞれ len 関数、cap 関数で得ることができる。

package main

import "fmt"

func main() {
    a := make([]int, 5, 10)

    fmt.Println(a)
    fmt.Println(len(a))
    fmt.Println(cap(a))
}

^o^ > go run slice4.go
[0 0 0 0 0]
5
10

スライスは、append 関数を使って末尾に要素を追加できる。

package main

import "fmt"

func main() {
    a := make([]int, 0)
    fmt.Println(a)

    for i := 0; i < 5; i++ {
        a = append(a, i)
        fmt.Println(a)
    }
}

^o^ > go run slice5.go
[]
[0]
[0 1]
[0 1 2]
[0 1 2 3]
[0 1 2 3 4]

容量を超えて要素を追加しようとすると、スライスはよりを大きい容量の新しいメモリ領域を確保する。これは自動的に行われる。ちょっと試してみよう。

package main

import "fmt"

func main() {
    a := make([]int, 0)

    fmt.Printf("len=%d cap=%d %p %v\n", len(a), cap(a), a, a)

    for i := 1; i < 18; i++ {
        a = append(a, i)
        fmt.Printf("len=%d cap=%d %p %v\n", len(a), cap(a), a, a)
    }
}

^o^ > go run slice6.go
len=0 cap=0 0x526b88 []
len=1 cap=1 0xc0420381d8 [1]
len=2 cap=2 0xc042038220 [1 2]
len=3 cap=4 0xc04203e500 [1 2 3]
len=4 cap=4 0xc04203e500 [1 2 3 4]
len=5 cap=8 0xc042040140 [1 2 3 4 5]
len=6 cap=8 0xc042040140 [1 2 3 4 5 6]
len=7 cap=8 0xc042040140 [1 2 3 4 5 6 7]
len=8 cap=8 0xc042040140 [1 2 3 4 5 6 7 8]
len=9 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9]
len=10 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9 10]
len=11 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9 10 11]
len=12 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9 10 11 12]
len=13 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9 10 11 12 13]
len=14 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9 10 11 12 13 14]
len=15 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15]
len=16 cap=16 0xc042052180 [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16]
len=17 cap=32 0xc042032100 [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17]

%p は変数のポインタを表す書式指定子。上の例を見ると、大きさ（len）が容量（cap）を超えるタイミングで容量も大きくなり、同時にポインタの値も変化していく様子が見て取れる。

スライスは配列に似ているが、要素を追加することによって大きさ（長さ）を変更できるデータ構造。大きさの変更は自動的になされる。小さくすることはできない。たぶん。

スライスの宣言は次のように大きさを指定せずに行う。

var 変数名 []型

同時に初期化するには：

var 変数名 []型 = []型{ 値1, 値2, 値3, ... }
var 変数名 = []型{ 値1, 値2, 値3, ... }

大きさを指定しないことを除けば、配列と一緒だな。ちょっと試してみよう。

package main

import "fmt"

func main() {
    var s1 []int
    var s2 []int = []int{ 1,2,3,4,5 }
    var s3 = []int{ 6,7,8,9,10 }

    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
}

^o^ > go run slice.go
[]
[1 2 3 4 5]
[6 7 8 9 10]

スライスはまた、配列の部分列を取り出すことでも作れる。

操作	意味
s[m:n]	m から n – 1 まで
s[m:]	m から最後尾まで
s[:n]	先頭から n – 1 まで
s[:]	先頭から最後尾まで

package main

import "fmt"

func main() {
    var array = [8]int{ 1,2,3,4,5,6,7,8 }

    var s1 = array[2:6]
    var s2 = array[3:]
    var s3 = array[:3]
    var s4 = array[:]

    fmt.Println(s1)
    fmt.Println(s2)
    fmt.Println(s3)
    fmt.Println(s4)
}

^o^ > go run slice2.go
[3 4 5 6]
[4 5 6 7 8]
[1 2 3]
[1 2 3 4 5 6 7 8]

スライスを配列の部分列として取り出した場合、元の配列とデータ格納領域を共有することに注意。つまり、スライスの要素を変更すると、元の配列の対応する要素も変更される。

package main

import "fmt"

func main() {
    var array = [4]int{ 1,2,3,4 }

    fmt.Println(array)

    var s = array[:]
    s[2] = 10

    fmt.Println(s)
    fmt.Println(array)
}

^o^ > go run slice3.go
[1 2 3 4]
[1 2 10 4]
[1 2 10 4]

配列は次のように大きさ（長さ）と要素の型を合わせて宣言する。

var 変数名 [大きさ]型

要素の型が決まっているので、同じ配列に異なる型の要素を格納することはできない。
また、大きさも含めて配列の型なので、要素の型が同じでも大きさが異なれば別の型とみなされる。例えば [4]int と [8]int は別の型だ。

宣言と同時に初期化するには次のようにする。

var 変数名 [大きさ]型 = [大きさ]型{ 値0, 値1, 値2, 値3, ... }

または

var 変数名 = [大きさ]型{ 値0, 値1, 値2, 値3, ... }

初期化しないと、配列の要素はゼロ値になる。

少し試してみよう。

package main

import "fmt"

func main() {
    var a [4]int
    var b [6]int = [6]int{ 0, 1, 2, 3, 4, 5 }
    var c = [8]int { 0, 1, 2, 3, 4, 5, 6, 7 }

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

o^ > go run array.go
[0 0 0 0]
[0 1 2 3 4 5]
[0 1 2 3 4 5 6 7]

配列の要素にアクセスするには、[] を使ってインデックスを指定する。インデックスは 0 始まりだ。

package main

import "fmt"

func main() {
    var a [4]int = [4]int{ 1, 2, 3, 4 }

    fmt.Println(a[2])
    fmt.Println(a)

    a[1] = 7

    fmt.Println(a[1])
    fmt.Println(a)
}

^o^ > go run array2.go
3
[1 2 3 4]
7
[1 7 3 4]

最後に len 関数について書いておこう。len 関数は配列の大きさ（長さ）を返す。

package main

import "fmt"

func main() {
    var a [4]int = [4]int{ 1, 2, 3, 4 }

    fmt.Println(a)
    fmt.Println(len(a))
}

^o^ > go run array3.go
[1 2 3 4]
4

条件分岐には if 文のほかにもうひとつ、switch 文がある。switch 文は次の通り。

switch 条件式 {
    case 式A:
        処理A1
        処理A2
        処理A3
    case 式B:
        処理B1
        処理B2
        処理B3
    case 式C:
        処理C1
        処理C2
        処理C3
    default:
        処理Z1
        処理Z2
        処理Z3
}

条件式の値と case 節の式A、B、C の値が順に比較され、等しくなる最初の case 節の処理が実行される。どの case 節の式とも等しくなければ default 節が実行される。
試してみよう。お題は FizzBuzz 問題だ。

package main

import "fmt"

func main() {
    i := 1

    for i <= 20 {
        switch i % 15 {
            case 0:
                fmt.Println("FizzBuzz")
                i++
            case 3, 6, 9, 12:
                fmt.Println("Fizz")
                i++
            case 5, 10:
                fmt.Println("Buzz")
                i++
            default:
                fmt.Println(i)
                i++
        }
    }
}

^o^ > go run switch.go
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz

例題のために冗長な書き方にしたけど、期待通り動いている。見ればわかるように、case 節の式はひとつでなくてもいい。
また、条件式を書かない書き方もある。この場合には case 節の式の値が true になる最初の節が実行される。

package main

import "fmt"

func main() {
    i := 1

    for i <= 20 {
        switch {
            case i % 15 == 0:
                fmt.Println("FizzBuzz")
            case i % 3 == 0:
                fmt.Println("Fizz")
            case i % 5 == 0:
                fmt.Println("Buzz")
            default:
                fmt.Println(i)
        }
        i++
    }
}

^o^ > go run switch2.go
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz

for 文で、条件部を省略してただ for と書くと無限ループになる。

for {
    処理
}

ループの制御として、break と continue がある。break はループを抜け、continue はループの頭に戻る。
試してみよう。

package main

import "fmt"

func main() {
    i := 0

    for {
        if i > 10 {
            break
        } else if i % 3 == 0 {
            i++
            continue
        } else {
             fmt.Println(i)
        }
        i++
    }
}

^o^ > go run for_inf.go
1
2
4
5
7
8
10

Go の繰り返し構文には for しかない。だけどこの for には 3 通りの使い方があって、ひとつは普通の for、ひとつは while 的なもの、そしてもひとつはいわゆる for each 的なものだ。
順番に見ていこう。

まずひとつめ、普通の for。「普通の」というのは、繰り返し用変数の初期化と繰り返し条件、変数の更新処理がある C や JavaScript なんかと同じ、くらいの意味。ただしカッコは要らない。

package main

import "fmt"

func main() {
    names := []string{ "Andy", "Bill", "Charlie" }

    for i := 0; i < 3; i++ {
        fmt.Println(names[i])
    }
}

names := []string{ "Andy", "Bill", "Charlie" } というところは、スライスっていう配列みたいなものを作ってるんだけど、これについては別の機会に書く。
実行してみよう。

^o^ > go run for.go
Andy
Bill
Charlie

ふたつめの使い方は while のようなもの。というか while そのものだ。for の後に繰り返し条件だけを書く。

package main

import "fmt"

func main() {
    names := []string{ "Andy", "Bill", "Charlie" }

    i := 0
    for i < 3 {
        fmt.Println(names[i])
        i++
    }
}

^o^ > go run for_while.go
Andy
Bill
Charlie

最後はいわゆる for each 的な使い方。range キーワードを使って、スライス（または配列）のインデックスと要素を一つずつ取り出して繰り返す。

package main

import "fmt"

func main() {
    names := []string{ "Andy", "Bill", "Charlie" }

    for idx, name := range names {
        fmt.Println(idx, name)
    }
}

^o^ > go run for_range.go
0 Andy
1 Bill
2 Charlie

ここではインデックスを idx 変数で受け取っているけど、場合によっては使わないこともある。そういう時は次のように _ （アンダースコア）で受けてやる。そうしないと idx 変数を使っていない、という警告を受けることになる。アンダースコアは、「ここに入る値は使わないよ」ということを示すものだ。

for _, name := range names {
    fmt.Println(name)
}

Go の論理演算子には次のものがある。

演算子	意味
!x	x の否定
x && y	x かつ y
x || y	x または y

x、y は bool 型でなければならない。

変数を関数の外で宣言するとグローバル変数になる。グローバル変数は、同じファイル内のどの関数からでもアクセスできる。

package main

import "fmt"

var name = "Andy"

func hello() {
    fmt.Println("Hello, " + name + "!")
}

func main() {
    hello()
    fmt.Println("Good morning, " + name + ".")
}

^o^ > go run var_global.go
Hello, Andy!
Good morning, Andy.

関数の中で宣言されているのはローカル変数。ローカル変数はその関数の中だけで使える。