Go 學習筆記

第一章 型別

1.1 變數

Go 語言變數名由字母、數字、下劃線組成，其中首個字母不能為數字。
Go 是靜態型別語⾔，不能在運⾏期改變變數型別。
使⽤關鍵字 var 定義變數，⾃動初始化為零值。如果提供初始化值，可省略變數型別，由編譯器⾃動推斷。

var x int 
var y int  = 1
var radius float32 = 2.0
var str = "Hello Go"

在函式內部，可⽤更簡略的 “:=” ⽅式定義變數。

var func main(){
    m:="abc"
} 

可以一次定義多個變數。

var x,y,z int
 
 //定義全域性變數
var m,n = "abc",123  
var (
    a int
    b float32
)
var func main(){
    i := "Hello Go" //編譯器會將未使⽤的區域性變數當做錯誤=>i declared and not used。
    println(x, n, b)
} 

注意重新賦值與定義新同名變數的區別。

var (
    a int
    b float32
)

func main() {
    println(&a)

    m := "Hello Go"
    println(&m)

    m, n := "what?"
 
, 10 // 重新賦值: 與前 m 在同 層次的程式碼塊中，且有新的變數被定義。
    println(&m, n)

    a := 12 // 定義新同名變數: 不在同層次程式碼塊。
    println(&a)
}  

輸出結果

0x10b29a8
0xc420039f68
0xc420039f68 10
0xc420039f60

1.2 常量

常量值必須是編譯期可確定的數字、字串、布林值。

const x, y, z = 1, "Hello Go", false //多常量初始化

const ( //常量組
    m    = false
    n    = false
 

    i, j = "abc", 1 //型別自動判斷
)

func main() {
    const x = 2//未使用區域性常量不會引發編譯錯誤
}

在常量組中，如不提供型別和初始化值，那麼視作與上 常量相同。

const ( //常量組
    m = false
    n   //n = false
    i = 10
    j   //j = 10
)

常量值還可以是 len、cap、unsafe.Sizeof 等編譯期可確定結果的函式返回值。

const (
    x = "Hello Go"
    y = len(x)
    z = unsafe.Sizeof(x)
)

如果常量型別 以儲存初始化值，那麼不會引發溢位錯誤。

const (
    x byte = 20
    y int  = 1e20//constant 100000000000000000000 overflows int
)

列舉
關鍵字 iota 定義常量組中從 0 開始按 計數的 增列舉值。

const (
    Sunday = iota //0
    Monday        //1
    Tuesday       //2
    Wednesday     //3
    Thursday      //4
    Friday        //5
    Saturday      //6
)

const (
    _        = iota             // iota = 0
    KB int64 = 1 << (10 * iota) // iota = 1
    MB                          // 與 KB 表示式相同，但 iota = 2  等同於=> MB int64 = 1 << (10 * 2)
    GB
    TB
)

在同 常量組中，可以提供多個 iota，它們各增 。

const (
    A, B = iota, iota << 10 //0,0 << 10
)

如果 iota 增被打斷，須顯式恢復。

const (
    A = iota //1
    B        //2
    C = "c"  //c
    D        //c
    E = iota //4 顯式恢復。注意計數包含了 C、D 兩行 。
    F        //5
    G        //6
)

1.3 基本型別

支援八進位制、 十六進位制，以及科學記數法。標準庫 math 定義了各數字型別取值範圍。

a, b, c, d := 071, 0x1F, 1e9, math.MinInt16

空指標值 nil

1.4 引用型別

引 型別包括 slice、map 和 channel。它們有複雜的內部結構，除了申請記憶體外，還需
要初始化相關屬性。
內建函式 new 計算型別 ，為其分配零值記憶體，返回指標。 make 會被編譯器翻譯 成具體的建立函式，由其分配記憶體和初始化成員結構，返回物件 指標。

number := []int{0, 0, 0}
number[1] = 10

x := make([]int, 3) // len = 3  slice.c: runtime·makeslice
x[1] = 10

y := new([]int)
y[0] = 10 // Error: invalid operation: y[1] (index of type *[]int)

1.5 型別轉換

不⽀持隱式型別轉換，即便是從窄向寬轉換也不⾏。

var x byte = 10
//var m int = x //cannot use x (type byte) as type int in assignment
y := int(x)

同樣不能將其他型別當 bool 值使⽤。

var x  = 1
if x {//non-bool x (type int) used as if condition
    println("true")
}

1.6 字串

字串是不可變值型別，內部⽤指標指向 UTF-8 位元組陣列。
• 預設值是空字串 “”。
• ⽤索引號訪問某位元組，如 s[i]。
• 不能⽤序號獲取位元組元素指標，&s[i] ⾮法。
• 不可變型別，⽆法修改位元組陣列。
• 位元組陣列尾部不包含 NULL。

// string is the set of all strings of 8-bit bytes, conventionally but not
// necessarily representing UTF-8-encoded text. A string may be empty, but
// not nil. Values of string type are immutable.
type string string

使⽤索引號訪問字元 (byte)。

var str = "Hello Goland"

println(str[0] == 72, str[1], str[len(str)-1])

輸出

true 101 100

連線跨⾏字串時，”+” 必須在上⼀⾏末尾，否則導致編譯錯誤。

var str = "Hello " + " Goland"

s2 := "Hello, "
    + "World!" //invalid operation: + untyped string

println(str)
println(s2)

⽀持⽤兩個索引號返回⼦串。⼦串依然指向原位元組陣列，僅修改了指標和⻓度屬性。

str := "Hello " + " Goland"

str1 := str[1:]  //ello  Goland
str2 := str[:6]  //Hello 
str3 := str[2:5] //llo

println(str1)
println(str2)
println(str3)

單引號字元常量表⽰ Unicode Code Point，⽀持 \uFFFF、\U7FFFFFFF、\xFF 格式。
對應 rune(int32) 型別，UCS-4。

func main() {
    fmt.Printf("%T\n", 'a')
    var c1, c2 rune = '\u6211', '們'
    println(c1 == '我', string(c2) == "\xe4\xbb\xac")
}

輸出

int32
true true

要修改字串，可先將其轉換成 []rune 或 []byte，完成後再轉換為 string。⽆論哪種轉
換，都會重新分配記憶體，並複製位元組陣列。

str := "Hello Goland"
number := "110"

s := []byte(str)
phone := []rune(number)

s[0] = 'F'
phone[len(number)-1] = '9'

println(string(s))
println(string(phone))

輸出

Fello Goland
119

⽤ for 迴圈遍歷字串時，也有 byte 和 rune 兩種⽅式。

str := "Hello"

for i := 0; i < len(str); i++ { //byte
    fmt.Printf("str[%d] = %c \n", i, str[i])
}

for _, value := range str {     //rune
    fmt.Printf("%c\n", value)
}

輸出

str[0] = H 
str[1] = e 
str[2] = l 
str[3] = l 
str[4] = o 
H
e
l
l
o

1.7 指標

⽀持指標型別 T，指標的指標 **T，以及包含包名字首的 \

type User struct {
    name string
}

user := User{"小強"}
userIp := &user

var ipStr *User
ipStr = &user

println(ipStr)
println(userIp)
fmt.Printf("name=%s\n", userIp.name) 

輸出

0xc420039f58
name=小強
0xc420039f58

不能對指標做加減法等運算。

number := 1234
p := &number
p++ //invalid operation: p++ (non-numeric type *int)

可以在 unsafe.Pointer 和任意型別指標間進⾏轉換。

x := 0x12345678
p := unsafe.Pointer(&x) // *int -> Pointer
n := (*[4]byte)(p)      // Pointer -> *[4]byte
for i := 0; i < len(n); i++ {
    fmt.Printf("%X ", n[i])
}

輸出

78 56 34 12 0xc420039f48

返回區域性變數指標是安全的，編譯器會根據需要將其分配在 GC Heap 上。

func test() *int {
 x := 100
 return &x // 在堆上分配 x 記憶體。但在內聯時，也可能直接分配在目標棧。
}

將 Pointer 轉換成 uintptr，可變相實現指標運算。

func main() {
    d := struct {
        s string
        x int
    }{"abc", 100}
    p := uintptr(unsafe.Pointer(&d)) // *struct -> Pointer -> uintptr
    p += unsafe.Offsetof(d.x)        // uintptr + offset
    p2 := unsafe.Pointer(p)          // uintptr -> Pointer
    px := (*int)(p2)                 // Pointer -> *int
    *px = 200                        // d.x = 200
    fmt.Printf("%#v\n", d)
}

輸出

struct { s string; x int }{s:"abc", x:200}

注意：GC 把 uintptr 當成普通整數物件，它⽆法阻⽌ “關聯” 物件被回收。