GO語言總結(2)——基本類型

　　上篇博文總結了Go語言的基礎知識——GO語言總結(1)——基本知識  ，本篇博文介紹Go語言的基本類型。

1、整型

　　go語言有13種整形，其中有2種只是名字不一樣，實質是同樣的，因此，實質上go語言有11種整形。以下：

　　（1）int ：　　依賴不一樣平臺下的實現，能夠是int32或int64

　　（2）int8 :　　　　　　　　　　  (-128　　->　　127)

　　（3）int16: 　　　　　　　　　　(-32768　　->　　32767)

　　（4）int32:　　　　　　　　　　 (-2 147 483 648　　->　　2 147 483 647)

　　（5）int64 :　　　　　　　　　　(-9 223 372 036 854 775 808　　->　　9 223 372 036 854 775 807)

 

　　（6）unit :　　　　　　　　　　 依賴不一樣平臺下的實現，能夠是int32或int64

　　（7）unit8 (又名byte):　　　　  (0　　->　　255)

　　（8）unit16 :　　　　　　　　   (0　　->　　65535)

　　（9）unit32 (又名rune):　　　   (0　　->　　4 294 967 295)

　　（10）unit64 :　　　　　　　　 (0　　->　　18 446 744 073 709 551 615)

 

　　（11）unitptr : 　　　　　　　　剛好容納指針值的類型，對32位平臺是unit32，對64位平臺是unit64

　　（PS :　值得注意的是，go語言中沒有自動類型轉換，這意味着，除了上篇博文分析的比較運算符以外，其餘的操做符基本須要類型轉換，才能進行操做。不然就是編譯錯誤）

 

2、浮點類型

　　go語言有2種類型的浮點和兩種類型的複數類型。

　　（1） float32　　　　　　　　(-3.402...×10³⁸->　　3.402...×10³⁸)

　　（2） float64　　　　　　　　(-1.797...×10³⁰⁸->　　+1.797...×10³⁰⁸)

　　（3） complex64　　　　　　( 實部、虛部都是一個float32 )

　　（4） complex128　　　　　 ( 實部、虛部都是一個float64 )

　　（PS：標準庫math包中，包含了衆多數學函數，其中全部函數均使用float64，

　　　　標準庫math/cmplx包含衆多複數相關的數學函數,其中全部函數均使用complex128）

　　（PPS : 跟數學中同樣，Go語言使用後綴 i 表示複數,例如 5 + 5.1i ）

      

3、字符串

　　Go語言的字符串是用UTF-8編碼的變寬字符序列，每一個字符都用一個或多個字節表示。這與Java不一樣，Java是採用UTF-16來表示，每一個字符都對應2個字節。

　　（1）建立：一種是用雙引號（"）括起來，它表示可解析的字符串，能夠進行字符轉義。另外一種是用單引號（'）括起來，它表示原生的字符串，能夠包含除反引號以外的任何字符，固然也能夠換行。以下：　

func test1() {
    str1 := "\"it's me!\""
    str2 := `"it's me,too"`
    fmt.Println(str1)
    fmt.Println(str2)
}

輸出爲：

"it's me!"
"it's me,too"

　　（2）Go語言的字符串支持 「+=」操做，能夠經過[n]獲取索引處的原始字節、經過[n:m]、[n:]、[:m]來獲取字節對應的字符串，若字符被截段，顯示亂碼。如：

func test1() {
    str1 := "Go語言的字符串是用UTF-8編碼的變寬字符序列，每一個字符都用一個或多個字節表示。"
    fmt.Println(str1[4:15])
    fmt.Println(str1[5:15])
    fmt.Println(str1[5])
    fmt.Println(str1[:5])
    fmt.Println(len(str1))         //字節數
    fmt.Println(len([]rune(str1))) //字符數
}

輸出爲 ：

�言的字�
言的字�
232
Go語
109
41

　　（3）字符串支持常規的比較運算符操做，比較運算符在內存中一個字節一個字節的比較字符串。固然了，這個比較是按照utf-8編碼的順序進行比較的。

　　（4）上例的最後一個取字符數的操做：len([]rune(str1))，在Go語言中，一個字符串能夠能夠用一個rune（又名int32）數組來表示，每一個rune都表示一個單一的字符。如：

func test1() {
    str1 := "Go語言的字符串是用UTF-8編碼的變寬字符序列，每一個字符都用一個或多個字節表示。"
    for _, char := range []rune(str1) {
        fmt.Println(char)
    }
}

這個操做會將str1的每一個字符數字直接打印出來

 

4、指針

（1）指針的本質，用一個簡單例子說明一下:

func test2() {
    a := "xyz"
    b := "opq"
    pa := &a  //pa爲指向a的指針
    pp := &pa //pp爲指向pa的指針
    fmt.Println(a, b, *pa, **pp)
    a += "zz" //a追加「zz」
    fmt.Println(a, b, *pa, **pp)
    *pa += "bb" //pp指向的值，追加"bb"
    fmt.Println(a, b, *pa, **pp)
    fmt.Println("打印a各類狀況：", &a, a)
    fmt.Println("打印pa各類狀況：", &pa, pa, *pa)
    fmt.Println("打印pp各類狀況：", &pp, pp, *pp, **pp)
}

 輸出以下:

xyz opq xyz xyz
xyzzz opq xyzzz xyzzz
xyzzzbb opq xyzzzbb xyzzzbb
打印a各類狀況： 0xc0820001d0 xyzzzbb
打印pa各類狀況： 0xc082038018 0xc0820001d0 xyzzzbb
打印pp各類狀況： 0xc082038020 0xc082038018 0xc0820001d0 xyzzzbb

 可見，指針的本質就是一個存放邏輯地址的變量。

（2）有兩種建立變量的語法，同時得到指向它們的指針：new(Type) 和 &Type{}, 以下：

type point struct {
    x int
    y int
}

func test3() {
    a := point{1, 2}
    b := new(point)
    c := &point{}
    d := &point{3, 4}
    fmt.Println(a, b, c, d)
}

輸出爲：

{1 2} &{0 0} &{0 0} &{3 4}

 Go語言打印指向結構體的指針時，會打印解引用後的結構體內容，同時會將&做爲前綴，表示它是一個指針。

值得注意的是，若是Type不是一個能夠用大括號初始化的類型，那就只能使用內置函數 new(Type)了。以下：

func test5() {
    //建立一個int變量，並得到它的指針
    var1 := new(int)
    //var1 := &int32{}
    fmt.Printf("%T->%v\n", var1, var1)
}

 

int不可使用大括號初始化，因此第二種會報錯，註釋掉後，輸出：

*int->0xc082006270

 

 

參考：《Go語言程序設計》