Go 定義編

Go 変数の宣言

初期値あり

    var i int = 1
    var f64 float64 = 1.2
    var s string = "test"
    var t bool = true
    var f bool = false

( )でまとめて定義することも可能

var (
    i    int     = 1
    f64  float64 = 1.2
    s    string  = "test"
    // ワンライナーで複数定義
    t, f bool    = true, false
)

期値なし

var i int
var f64 float64
var s string
var t bool
var f bool

Short variable declarations

• varを省略可能
• 関数内のみでしか宣言できない
• 値から型を推測できるので省略可能
• 明示的に型を宣言する場合はvarを使用して宣言する
• 再代入可能だが再宣言は不可

func foo() {
    xi := 1
    xf64 := 1.2
    xs := "test"
    xt, xf := true, false
}

const

constの定義

const Pi = 3.14

( )でまとめて定義することも可能

const (
    Username = "test_user"
    Password = "test_pass"
)

オーバーフロー

型を定義した変数においてintで扱える最大数から計算をしようとするとオーバーフローする

var big int = 999999999999999999999 - 1
>>> untyped int constant 1000000000000000000000) as int value in variable declaration (overflows)

const定義の場合は明確に型を定義していないので 計算後に値をintとして出力することができるのでエラーにはならない

const big = 999999999999999999999 - 1
>>> 999999999999999999998

数値型

代表的な数値の型

uint8

int8

float32

complex64

var (
    u8  uint8     = 255
    i8  int8      = 127
    f32 float32   = 0.2
    c64 complex64 = -5 + 12i
　　)

四則演算

fmt.Println("1 + 1 = ", 1+1)　         >>> 1 + 1 =  2
fmt.Println("10 - 1 = ", 10-1)　       >>> 10 - 1 =  9
fmt.Println("10 / 2 = ", 10/2)　       >>> 10 / 2 =  5
fmt.Println("10 / 3 = ", 10/3)　       >>> 10 / 3 =  3
fmt.Println("10.0 / 3 = ", 10.0/3)   >>> 10.0 / 3 =  3.3333333333333335
fmt.Println("10 / 3.0 = ", 10/3.0)   >>> 10 / 3.0 =  3.3333333333333335 
fmt.Println("10 % 2 = ", 10%2)　        >>> 10 % 2 =  0
fmt.Println("10 % 3 = ", 10%3)　  >>> 10 % 3 =  1

ビット演算子（シフト）

   x := 0
    fmt.Println(x)
    // x = x + 1
    x++
    fmt.Println(x)
    // x = x - 1
    x--
    fmt.Println(x)

文字列型

基本

fmt.Println("Hello World")
fmt.Println("Hello " + "World")
// ASCⅡ コード
fmt.Println("Hello World"[0]) 
>>> 72
fmt.Println(string("Hello World"[0])) 
>>> H

文字列の置換

*stringsパッケージをimportすること

下記例は変数stringをコピーして出力している(値渡し)

var s string = "Hello World"

fmt.Println(strings.Replace(s, "H", "X", 1))

>>> Xello World

// 参照渡しの場合
s = strings.Replace(s, "H", "X", 1)

文字を含むかの問合せ

fmt.Println(strings.Contains(s, "World"))

改行

fmt.Println("Test\n" + "Test")

// ``で囲う
fmt.Println(`Test2
 Test2
    Test2`)

"(ダブルクォーテーション)の出力

fmt.Println("\"")

fmt.Println(`"`)

論理値型

//var t, f bool = true, false
t, f := true, false
fmt.Printf("%T %v %t\n", t, t, t)
fmt.Printf("%T %v %t\n", f, f, t)

分離演算子

fmt.Println(true && true)   // true
fmt.Println(true && false)  // false
fmt.Println(false && false) // false

fmt.Println(true || true)   // true
fmt.Println(true || false)  // true
fmt.Println(false || false) // false

fmt.Println(!true)  // false
fmt.Println(!false) // true

# 型変換
##### int, floatの型変換
var x int = 1
xx := float64(x)
fmt.Printf("%T %v %f\n", xx, xx, xx) // float64 1 1.000000

    var y float64 = 1.2
    yy := int(y)
    // %dでintは表示できる
    fmt.Printf("%T %v %d\n", yy, yy, yy) // int 1 1

配列

package main

import "fmt"

func main(){
    //[2]intの部分が型となるので変更が効かない
    // 配列を宣言
    var a [2]int
    a[0] = 100
    a[1] = 200
    fmt.Println(a)
    
    // 初期値として値を入れる場合
    var b [2]int = [2]int{100, 200}
    fmt.Println(b)
    
    // var b [3]int = [3]int{100, 200}
    // b = append(b, 300) // errorになる
    
    var c []int = []int{100, 200}
    c = append(c, 300)
    fmt.Println(c)
}