Go言語 のバックアップ(No.5) - 闘うITエンジニアの覚え書き

package main

import "fmt"

func main(){
    var myInt int = 1 
    var myInt8 int8 = 1 
    var myInt64 int64 = 1 
    var myUint uint = 1 
    var myByte byte = 0x01
    var myRune rune = 0x01
    fmt.Printf("myInt   : %T\n", myInt)
    fmt.Printf("myInt8  : %T\n", myInt8)
    fmt.Printf("myInt64 : %T\n", myInt64)
    fmt.Printf("myUint  : %T\n", myUint)
    fmt.Printf("myByte  : %T\n", myByte)
    fmt.Printf("myRune  : %T\n", myRune)
}

結果

myInt   : int
myInt8  : int8
myInt64 : int64
myUint  : uint
myByte  : uint8
myRune  : int32

package main

import "fmt"

func main(){
    var myFloat32 float32 = 1.234
    var myFloat64 float64 = 1.234
    fmt.Printf("myFloat32 : %T, %f\n", myFloat32, myFloat32)
    fmt.Printf("myFloat64 : %T, %f\n", myFloat64, myFloat64)
}

結果

myFloat32 : float32, 1.234000
myFloat64 : float64, 1.234000

package main

import "fmt"

func main(){
    var myString string = "ABC"
    fmt.Printf("myString : %T, %s\n", myString, myString)
}

結果

myString : string, ABC

package main

import "fmt"

func main(){
    var myBool bool = true
    fmt.Printf("myBool : %T, %v\n", myBool, myBool)
}

結果

myBool : bool, true

package main

import "fmt"

func main(){

    // 数値の配列
    var array1 [2]int
    array1[0] = 1 
    array1[1] = 2 
    for i,val := range array1{
        fmt.Printf("array1[%d] = %d\n", i, val)
    }   

    // 宣言と同時に初期化
    array2 := []int{1,2}
    for i,val := range array2{
        fmt.Printf("array2[%d] = %d\n", i, val)
    }   

    // 文字列の配列
    array3 := []string{"A", "B"}
    for i,val := range array3{
        fmt.Printf("array3[%d] = %s\n", i, val)
    }   
}

結果

array1[0] = 1
array1[1] = 2
array2[0] = 1
array2[1] = 2
array3[0] = A
array3[1] = B

package main

import "fmt"

func main(){

    // マップの宣言と値の代入
    var map1 map[string]string = make(map[string]string)
    //var map1 map[string]string = map[string]string{}  // 上記と同義
    //map1 := map[string]string{}                       // 上記と同義
    map1["key1"] = "A" 
    map1["key2"] = "B" 
    for key,val := range map1{
        fmt.Printf("map1[%s] = %s\n", key, val)
    }   

    // 宣言と同時に初期化
    map2 := map[string]string{"key1": "C", "key2": "D"}
    for key,val := range map2{
        fmt.Printf("map2[%s] = %s\n", key, val)
    }   
}

結果

map1[key1] = A
map1[key2] = B
map2[key1] = C
map2[key2] = D

package main

import "fmt"

func main(){

    num := 10
    str := "ABC"

    var p1 *int = &num      // numのアドレスを取得
    var p2 *string = &str   // strのアドレスを取得

    fmt.Printf("p1 address: %v\n", p1) 
    fmt.Printf("p1 value: %v\n", *p1)
    fmt.Printf("p2 address: %v\n", p2) 
    fmt.Printf("p2 value: %v\n", *p2)
}

結果

p1 address: 0xc000016078
p1 value: 10
p2 address: 0xc000010200
p2 value: ABC

package main

import "fmt"

type MyStruct struct {
    name string
    age int 
}

func main(){
    var s1 MyStruct
    s1.name = "Taro"
    s1.age  = 20
    fmt.Printf("%T, %+v\n", s1, s1) 

    var s2 = MyStruct{name: "Jiro", age: 10} 
    fmt.Printf("%T, %+v\n", s2, s2) 
}

結果

main.MyStruct, {name:Taro age:20}
main.MyStruct, {name:Jiro age:10}

go には null は存在しない。
代わりにポインタ等が初期化されているかどうかの判断には nil が使用できる。
ちなみに string や int 等の変数には nil は代入できない。

package main

import "fmt"

func main(){

    str := "ABCD"

    var p1 *string
    if p1 == nil {
        p1 = &str
        fmt.Println("p1 set!")
    }   
    fmt.Printf("%T, %+v\n", p1, *p1)
}

結果

p1 set!
*string, ABCD

package main

import "fmt"

func main(){

    x := 3

    if x == 1 { 
        fmt.Println("x is 1")
    } else if x == 2 { 
        fmt.Println("x is 2")
    } else {
        fmt.Println("others")
    }   
}

他の言語と同様に switch も使用できる。
ただし Java等と違って break を書く必要がない点が異なる。
逆に、次の case に遷移させたい場合は、fallthrough を使用する。

package main

import "fmt"

func main(){

    x := 3

    switch x { 
    case 1:
      fmt.Println("x is 1")
    case 2:
      fmt.Println("x is 2")
    case 3:
      fmt.Println("x is 3")
      fallthrough
    default:
      // x = 3 の時だけここが実行される
      fmt.Println("others")
    }

    // 以下の書き方も可能
    switch {
    case x == 1:
      fmt.Println("x is 1")
    case x == 2:
      fmt.Println("x is 2")
    case x == 3:
      fmt.Println("x is 3")
    }
}

panic 関数が実行されると panic呼び出し以降の処理を中断し、コールスタックを巻き戻す。

package main

import "fmt"

func func1() int {
    panic("func1 error!\n");
    return 10
}

func main(){
    fmt.Println("main start")
    res := func1()
    fmt.Printf("result = %+v\n", res)
    fmt.Println("main end")
}

実行結果

main start
panic: func1 error!


goroutine 1 [running]:
main.func1(...)
	/path_to/test_panic.go:14
main.main()
	/path_to/test_panic.go:21 +0x96
exit status 2

recover 関数は panic関数の引数を返し、コールスタックの巻き戻しを停止する。

package main

import "fmt"

func func1() int {
    defer func(){
        err := recover()
        if err != nil {
            fmt.Printf("error!! ... %+v", err)
        }   
    }() 
    panic("func1 error!\n");
    return 10
}


func main(){
    fmt.Println("main start")
    res := func1()
    fmt.Printf("result = %+v\n", res)
    fmt.Println("main end")
}

実行結果

main start
error!! ... func1 error!
result = 0
main end

大方のライブラリでは戻り値で error も返却される為、これをエラー判定に利用する。

f, err := os.Open("filename.ext")
if err != nil {
    // エラー処理
    log.Fatal(err)
}

自前のライブラリ/関数を実装する際も必要に応じて、戻り値として error を返すインターフェースを採用する。

package main

import "errors"
import "fmt"

func myDiv(a int, b int) (int, error) {
    if b == 0 { 
        return 0, errors.New("divide by zero")
    }   
    result := a / b 
    return result, nil 
}

func main(){
    res, err := myDiv(10, 0)
    if err != nil {
        fmt.Printf("Error!! ... %+v\n", err)
    } else {
        fmt.Printf("result = %v\n", res)
    }   
}

実行結果

Error!! ... divide by zero