數據的三種基礎類型：bool，數字，string 以及定義常量

• 布爾值：bool
• 數字類型
• 字符串：string
• 類型轉換
• 常量

 

布爾值：bool

- bool 類型表示一個布爾值，值為 true 或者 false。

- 與運算 &&：

　　- 當兩邊都為true時，結果才為true

　　- 示例：

package main

import "fmt"

func main() {  
    a := true
    b := false
    fmt.Println("a:", a, "b:", b)
    c := a && b
    fmt.Println("c:", c)
}

// 打印：a：true b：false
// 打印：c: false

 

- 或運算 ||

　　- 當兩邊有一個為true，結果便為true

　　- 示例：

package main

import "fmt"

func main() {  
    a := true
    b := false
    fmt.Println("a:", a, "b:", b)
    d := a || b
    fmt.Println("d:", d)
}

// 打印：a：true b：false
// 打印：c: true

 

數字類型

- 有符號整型：

　　- int8：表示 8 位有符號整型

　　　　- 大小：8 位

　　　　- 范圍：-128～127

　　- int16：表示 16 位有符號整型

- 大小：16 位
- 范圍：-32768～32767

　　- int32：表示 32 位有符號整型

　　　　- 大小：32 位

　　　　- 范圍：-2147483648～2147483647

　　- int64：表示 64 位有符號整型

　　　　- 大小：64 位

　　　　- 范圍：-9223372036854775808～9223372036854775807

　　- int：根據不同的底層平台（Underlying Platform），表示 32 或 64 位整型。除非對整型的大小有特定的需求，否則通常應該使用 int表示整型。

　　　　- 大小：在 32 位系統下是 32 位，而在 64 位系統下是 64 位。

　　　　- 范圍：在 32 位系統下是 -2147483648～2147483647，而在 64 位系統是 -9223372036854775808～9223372036854775807

- 無符號整型：

　　- uint8：表示 8 位無符號整型

　　　　- 大小：8 位

　　　　- 范圍：0～255

　　- uint16：表示 16 位無符號整型

　　　　- 大小：16 位

　　　　- 范圍：0～65535

　　- uint32：表示 32 位無符號整型

　　　　- 大小：32 位

　　　　- 范圍：0～4294967295

　　- uint64：表示 64 位無符號整型

　　　　- 大小：64 位

　　　　- 范圍：0～18446744073709551615

　　- uint：根據不同的底層平台，表示 32 或 64 位無符號整型。

　　　　- 大小：在 32 位系統下是 32 位，而在 64 位系統下是 64 位。

　　　　- 范圍：在 32 位系統下是 0～4294967295，而在 64 位系統是 0～18446744073709551615。

- 浮點型：

　　- float32：32 位浮點數
　　- float64：64 位浮點數

- 復數類型：

　　- complex64：實部和虛部都是 float32 類型的的復數。
　　- complex128：實部和虛部都是 float64 類型的的復數。

- 其他數字類型： 

　　- byte 是 uint8 的別名。
　　- rune 是 int32 的別名。

- 補充Printf 方法中的 %T （格式說明符）以及 %d（替換數字）

　　- unsafe.Sizeof()  該函數接收變量並返回它的字節大小; unsafe 包應該小心使用，因為使用 unsafe 包可能會帶來可移植性問題

　　- %T  格式說明符（Format Specifier），可以打印出變量的類型;

　　- %d 占位符，用來占位數字類型的值；

　　- 示例：

package main

import (  
    "fmt"
    "unsafe"
)

func main() {  
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
    fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) // a 的類型和大小
    fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) // b 的類型和大小
}

// 打印：
//    value of a is 89 and b is 95  
//    type of a is int, size of a is 4  
//    type of b is int, size of b is 4

 

字符串：string

- 介紹：

Go 語言中的字符串是一個字節切片。把內容放在雙引號""之間，
暫且可以認為一個字符串就是由很多字符組成的。

 

- 單獨獲取字符串的每一個字節：

　　- 由於字符串是一個字節切片，所以我們可以獲取字符串的每一個字節。

　　- len() 返回字符串中字節的數量

　　- %x  格式限定符用於指定 16 進制編碼

　　- %c  格式限定符用於打印字符串的字符

　　- 示例：

package main

import (
    "fmt"
)

// 定義函數printBytes；
func printBytes(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

// 定義函數printChars；
func printChars(s string) {
    for i:= 0; i < len(s); i++ {
        fmt.Printf("%c ",s[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}


// 打印結果：
    48 65 6c 6c 6f 20 57 6f 72 6c 64  
    H e l l o   W o r l d

 

- rune：

　　- rune是Go語言中的一個內建類型，也是int32的別稱，目的是為了解決不同編碼格式之間存在的問題；

　　- rune表示一個代碼點，代碼點無論占用多少字節，都可以用一個rune來表示，

　　- 示例：

package main

import (
    "fmt"
)

func printBytes(s string) {
    for i := 0; i < len(s); i++ {
        fmt.Printf("%x ", s[i])
    }
}

func printChars(s string) {
    runes := []rune(s)
    fmt.Println("runes:", runes)
    for i := 0; i < len(runes); i++ {
        fmt.Printf("%c ", runes[i])
    }
}

func main() {
    name := "Hello World"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
    fmt.Printf("\n\n")
    name = "Señor"
    printBytes(name)
    fmt.Printf("\n")
    printChars(name)
}



// 打印結果：
    48 65 6c 6c 6f 20 57 6f 72 6c 64 
    runes: [72 101 108 108 111 32 87 111 114 108 100]
    H e l l o   W o r l d 
    
    53 65 c3 b1 6f 72 
    runes: [83 101 241 111 114]
    S e ñ o r

 

- 字符串的 for range 循環

package main

import (
    "fmt"
)

func printCharsAndBytes(s string) {
    for index, rune := range s {
        fmt.Printf("%c starts at byte %d\n", rune, index)
    }
}

func main() {
    name := "Señor"
    printCharsAndBytes(name)
}

// 打印結果：
    S starts at byte 0  
    e starts at byte 1  
    ñ starts at byte 2
    o starts at byte 4  
    r starts at byte 5

// 可以看到 ñ 占用了兩個字節

 

 

- 用字節切片構造字符串

package main

import (  
    "fmt"
)

func main() {  
    byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9}
    str := string(byteSlice)
    fmt.Println(str)
}

// 打印結果：
    Café 

 

 

- 用 rune 切片構造字符串

package main

import (  
    "fmt"
)

func main() {  
    runeSlice := []rune{0x0053, 0x0065, 0x00f1, 0x006f, 0x0072}
    str := string(runeSlice)
    fmt.Println(str)
}

// 打印結果：
    Señor

 

 

- 字符串的長度：

　　- utf8 的包中有一個函數：RuneCountInString() 用來獲取字符串的長度。這個方法傳入一個字符串參數然后返回字符串中的 rune 的數量。

package main

import (  
    "fmt"
    "unicode/utf8"
)

func length(s string) {  
    fmt.Printf("length of %s is %d\n", s, utf8.RuneCountInString(s))
}
func main() { 
    word1 := "Señor" 
    length(word1)
    word2 := "Pets"
    length(word2)
}

// 打印結果：
    length of Señor is 5  
    length of Pets is 4

 

 

- 字符串不可變：

　　Go 中的字符串和Python 中的字符串一樣是不可變的。一旦一個字符串被創建，那么它將無法被修改。

　　- 錯誤示例： 

package main

import (  
    "fmt"
)

func mutate(s string)string {  
    s[0] = 'a'//any valid unicode character within single quote is a rune 
    return s
}
func main() {  
    h := "hello"
    fmt.Println(mutate(h))
}

// 報錯信息：cannot assign to s[0]。

 

 　　- 倘若真的想修改，可以借助 rune， 修改rune切片中的數值來達到對字符串的修改；

package main

import (  
    "fmt"
)

func mutate(s []rune) string {  
    s[0] = 'a' 
    return string(s)
}
func main() {  
    h := "hello"
    fmt.Println(mutate([]rune(h)))
}

 

 

類型轉換

- Go 有着非常嚴格的強類型特征。Go 沒有自動類型提升或類型轉換。

- 類型轉換 往往發生在不同類型的數字類型中； 比如：浮點數 和 無符號整數的轉換等等；

　　- 錯誤示例：

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //不允許 int + float64
    fmt.Println(sum)
}

// 報錯：main.go:10: invalid operation: i + j (mismatched types int and float64)
// 在 Go 中, i 的類型是 int ，而 j 的類型是 float64 ，把兩個不同類型的數相加，Go 不允許這樣的操作

　　

　　- 正確示例：

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + int(j) //j is converted to int
    fmt.Println(sum)
}

// 打印：122

 

- 不同類型的數據，相互賦值也會報錯：

　　- 示例：

package main

import (
    "fmt"
)

func main() {
    i := 10
    var j float64 = i // 若沒有顯式轉換，該語句會報錯
    fmt.Println("j", j)
}


// 報錯：cannot use i (type int) as type float64 in assignment

 

- 不同類型的數據，不能互相轉換；

　　- 示例： string類型的“10” 轉換為 int類型的 10

package main

import (
    "fmt"
)

func main() {
    var num string = "10"
    fmt.Printf(int(num))
｝

// 報錯：cannot convert num (type string) to type int

 

常量

- 介紹定義：

在 Go 語言中，術語"常量"用於表示固定的值。比如 5 、-89、 I love Go、67.89 等等。
用關鍵字 const 來聲明

- 常量的性質：

　　- 當常量初始化后，不能再重新賦值為其他的值；

　　- 常量的值，在編譯時就會被確定，所以不允許函數將返回值賦值給常量；

　　- 以上兩種錯誤示例：

// 錯誤一： 常量重新賦值：

package main

func main() {  
    const a = 55 // 允許
    a = 89       // 不允許重新賦值
}


// 錯誤二： 函數的返回值賦值給常量：
package main

import (  
    "fmt"
    "math"
)

func main() {  
    fmt.Println("Hello, playground")
    var a = math.Sqrt(4)   // 允許
    const b = math.Sqrt(4) // 不允許
}

 

- 字符串常量：

　　- 所有的字符串，都是常量

　　- 常量可以賦值給 “合適的” 類型，而不需要類型轉換；

package main

import (  
    "fmt"
)

func main() {  
    const a = "Sam"     // 定義的常量本身是沒有定義類型的，
    var name = a         // 但是該常量可以直接賦值給 name 默認為 字符串類型
    fmt.Printf("type %T value %v", name, name)

}

 

- 布爾值常量：

 　　布爾常量和字符串常量沒有什么不同。他們是兩個無類型的常量 true 和 false。

 

- 數字常量：

　　 - 數字常量 當它們被分配給變量 或者在需要類型的地方使用時，才需要類型；

 　　- 當數字常量賦值給不同的數字類型的變量時，數字常量的類型，會根據變量的類型而變，不過常量本身是沒有數據類型的；

package main

import (  
    "fmt"
)

func main() {  
    const a = 5
    var intVar int = a
    var int32Var int32 = a
    var float64Var float64 = a
    var complex64Var complex64 = a
    fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
}

// 打印內容：
    intVar 5 
    int32Var 5 
    float64Var 5 
    complex64Var (5+0i)

　　- 數字表達式：

　　　　- 數字常量可以在表達式中自由混合和匹配；

package main

import (  
    "fmt"
)

func main() {  
    const a = 5
    const b = 5.9
    var c = a / b
    fmt.Printf("c's type %T value %v", c, c)
}

// 打印內容：c's type float64 value 0.847457627118644