A Tour of goが長くてどこまでやったかわからなくなるので自分用まとめ
- パッケージ名はインポートパスの最後の要素と同じの名前
- goのメソッド名は最初の文字が大文字で始まる場合にpublic扱いで、それ以外はprivate(Exported names)
- 関数の引数は、変数名の後ろに型名を書く(Functions)
func add(x int, y int) int {
return x + y
}
- 関数の2つ以上の引数が同じ型である場合は、最後の型を残して省略出来る(Functions)
func add(x, y int) int {
return x + y
}
- 関数は複数の戻り値を返す事が出来る(Functions)
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("hello", "world")
}
- 返り値となる変数に名前をつけることができる。型を書くとI/Oが1行にまとまって見やすそう(Named return values)
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
- var宣言で型は省略出来る(Variables)
var c, python, java = true, false, "no!"
importと同様に、まとめて宣言可能
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5 + 12i)
)
- var宣言のかわりに、
:=を使う事もできる(Variables)
c, python, java := true, false, "no!"
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
}
}
その他
ここからは、実際に触ってみる途上で試してみた事とかのメモ
- importはディレクトリしか指定出来ない（ファイル単体をimportしようとするとエラーになる）