基本類型

雖然從底層而言，所有的數(shù)據(jù)都是由比特組成，但計(jì)算機(jī)一般操作的是固定大小的數(shù)，如整數(shù)、浮點(diǎn)數(shù)、比特?cái)?shù)組、內(nèi)存地址等。進(jìn)一步將這些數(shù)組織在一起，就可表達(dá)更多的對象，例如數(shù)據(jù)包、像素點(diǎn)、詩歌，甚至其他任何對象。Go語言提供了豐富的數(shù)據(jù)組織形式，這依賴于Go語言內(nèi)置的數(shù)據(jù)類型。這些內(nèi)置的數(shù)據(jù)類型，兼顧了硬件的特性和表達(dá)復(fù)雜數(shù)據(jù)結(jié)構(gòu)的便捷性。

基本類型匯總

布爾類型

布爾型的值只可以是常量 true 或者 false
簡單定義：

    var b bool = true

兩個相同類型的值可以通過 == 或者 != 等比較運(yùn)算符號來獲得一個布爾類型的值。

布爾值并不會隱式轉(zhuǎn)換為數(shù)字值0或1，反之亦然。必須使用一個顯式的if語句輔助轉(zhuǎn)換：

// 布爾類型轉(zhuǎn)換為0或者1
func btoi(b bool) int{
    if b {
        return 1
    }
    return 0
}

// 數(shù)字轉(zhuǎn)換為布爾類型
func itob(i int) bool { return i != 0 }

整形

Go語言中整形被分為三大類：int 、uint、uintptr
這三種類型的長度是跟據(jù)程序所在的操作系統(tǒng)來決定長度的：

• int 和 uint 在32位操作系統(tǒng)上，它們使用32位，4個字節(jié)，在64拉操作系統(tǒng)上，它們使用64位，8個字節(jié)。
• uintptr 的長度被設(shè)定為存儲指針的 uint32 或 uint64 整數(shù)

int 和uint又被稱為有符號整形和無符號整形
有符號整形：

• int8（-128 -> 127）
• int16（-32768 -> 32767）
• int32（-2,147,483,648 -> 2,147,483,647）
• int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

無符號整形：

• uint8（0 -> 255）
• uint16（0 -> 65,535）
• uint32（0 -> 4,294,967,295）
• uint64（0 -> 18,446,744,073,709,551,615）

用不同的進(jìn)制來表示整數(shù)：
十進(jìn)制：

    var Decimal int = 12

二進(jìn)制：

    var Binary int = 0b1100

八進(jìn)制：

    var Octal int = 0o14

十六進(jìn)制：

    var Hexadecimal int = 0xc

用fmt.printf()函數(shù)進(jìn)行輸出：

    func main() {
        var Decimal int = 12
        var Binary int = 0b1100
        var Octal int = 0o14
        var Hexadecimal int = 0xCvar

        fmt.Printf("10進(jìn)制數(shù) %d 表示的是: %d \n", Decimal, Decimal)     //12
        fmt.Printf("2進(jìn)制數(shù) %b 表示的是: %d \n", Binary, Binary)           //12
        fmt.Printf("8進(jìn)制數(shù) %o 表示的是: %d \n", Octal, Octal)             //12
        fmt.Printf("16進(jìn)制數(shù) %X 表示的是: %d \n", Hexadecimal, Hexadecimal)    //12
    }

跟據(jù)上面的輸出可以發(fā)現(xiàn)，在Go語言中使用二進(jìn)制、八進(jìn)制、十六進(jìn)制 非常的方便，只需要在數(shù)字前面加上：0b、0o、0x 就可以使用。

補(bǔ)充：

fmt.Printf() 函數(shù)據(jù)的格式化功能：

%b 表示為二進(jìn)制
%c 該值對應(yīng)的unicode碼值
%d 表示為十進(jìn)制
%o 表示為八進(jìn)制
%q 該值對應(yīng)的單引號括起來的go語法字符字面值，必要時會采用安全的轉(zhuǎn)義表示
%x 表示為十六進(jìn)制，使用a-f
%X 表示為十六進(jìn)制，使用A-F
%U 表示為Unicode格式：U+1234，等價(jià)于"U+%04X"
%E 用科學(xué)計(jì)數(shù)法表示
%f 用浮點(diǎn)數(shù)表示

浮點(diǎn)型

Go語言支持兩種浮點(diǎn)型數(shù)：float32 和 float64。這兩種浮點(diǎn)型數(shù)據(jù)格式遵循 IEEE 754標(biāo)準(zhǔn) ：

• float32（+- 1e-45 -> +- 3.4 * 1e38），可以使用常量定義：math.MaxFloat32。
• float64（+- 5 1e-324 -> 107 1e308），可以使用一個常量定義：math.MaxFloat64。

浮點(diǎn)型的零值為 0.0 ，在進(jìn)行除法運(yùn)算的時候，浮點(diǎn)型的零值可以為分母并且不會報(bào)錯，而整形的就會報(bào)錯。

float32 精確到小數(shù)點(diǎn)后 7 位，float64 精確到小數(shù)點(diǎn)后 15 位。由于精確度的緣故，你在使用 == 或者 != 來比較浮點(diǎn)數(shù)時應(yīng)當(dāng)非常小心。你最好在正式使用前測試對于精確度要求較高的運(yùn)算。也可以使用第三方包來完成這個操作。`go get github.com/shopspring/decimal

package main

func main() {
    var f float64 = 3.1415926
    fmt.Printf("保留兩個位小數(shù)：%.2f",f)    //3.14
    fmt.Printf("保留兩個位小數(shù)：%.3f",f)    //3.142
}

在日常使用中，我們經(jīng)常通常都使用 float64 來來定義浮點(diǎn)類型，因?yàn)?math 包里面，幾乎所有的方法，都支持 float64。
把float64 轉(zhuǎn)換為 int 類型：

func IntFromFloat64(x float64) int {
    if math.MinInt32 <= x && x <= math.MaxInt32 { 
        whole, fraction := math.Modf(x)
        if fraction >= 0.5 {
            whole++
        }
        return int(whole)
    }
    panic(fmt.Sprintf("%g is out of the int32 range", x))
}

復(fù)數(shù)

復(fù)數(shù)分為：

    complex64 的實(shí)部和虛部為32位，
    complex128 的實(shí)部和虛部為64位。

復(fù)數(shù)的簡單使用：

    var c1 complex64 = 5 + 10i
    fmt.Printf("The complex64 is: %v", c1)
    // 輸出： 5 + 10i

函數(shù) real(c) 和 imag(c) 可以分別獲得相應(yīng)的實(shí)數(shù)和虛數(shù)部分。

byte 和 rune 類型

組成每個字符串的元素叫做字符，通過遍厲字符串或者定義單個字符可以獲取，定義字符時用 ' 包裹起來。

    var testRune := '國'
    var testByte := 'a'
    fmt.Printf("字符的類型為：%T",testRune)    //rune
    fmt.Printf("字符的類型為：%T",testRune)    //byte

使用中文或者一些特殊字符和Unicode編碼的時候，一般都推薦定義為 rune 類型。

rune 類型為 int32 的別名
byte 類型為 uint8 的別名范圍為 (0~255)

字符串

Go語言中的字符串以原生數(shù)據(jù)類型出現(xiàn)，使用字符串就像使用其他原生數(shù)據(jù)類型（int、bool、float32、float64 等）一樣。 Go 語言里的字符串的內(nèi)部實(shí)現(xiàn)使用UTF-8編碼。 字符串的值為雙引號(")中的內(nèi)容，可以在Go語言的源碼中直接添加非ASCII碼字符，例如：

    var str string = "hello，世界！”

字符串其實(shí)多個是byte 類型和 rune 類型放在一起的類型，也就是 string 類型。

比如上面輸出的字符串hello ，在 ascii 編碼表中，每個字母對應(yīng)的編號是：104,101,108,108,111。
如果這樣的話，我們就可以輸出一組 []byte 數(shù)組，來看一下 string 的底層是什么結(jié)構(gòu)。

    import (
        "fmt")

    func main() {
        var mystr01 string = "hello"
        var mystr02 [5]byte = [5]byte{104, 101, 108, 108, 111}
        fmt.Printf("mystr01: %s\n", mystr01)
        fmt.Printf("mystr02: %s", mystr02)
    }

輸出的結(jié)果為：

    mystr01: hello
    mystr02: hello

上面這個例子就說明了 string 類型的底層就是由一組 byte 類型的數(shù)組組成的。
那么就可以通過數(shù)組的自帶函數(shù)來獲取字符串的長度：

    import (
        "fmt")

    func main() {
        var mystr string = "hello"
        fmt.Printf("mystr: %d\n", len(mystr))
        // 結(jié)果為：mystr: 5
    }

在Go 語言中，字符串之間可以直接通過 + 連接起來，例如：

    import (
        "fmt"
    )
    func main() {        
        s := "hel" + "lo," 
        s += "world!" 
        fmt.Println(s) 
        //輸出 “hello, world!”
    }

在遇到字符串?dāng)?shù)組時，也可以使用 Go 語言封裝好的方法 strings.Join() 或者使用字符緩沖 bytes.Buffer() 拼接都可以，并且效率也更高。

轉(zhuǎn)義字符

轉(zhuǎn)義字符 就是一類特殊字符，它們表示特殊的函意，可以用作輔助作用：

• \n：換行符
• \r：回車符
• \t：tab 鍵
• \u 或
• \U：Unicode 字符
• \：反斜杠自身

例如：

    import "fmt"

    func main() {
        str := "hello \n world"
        fmt.Println(str)
        // 輸出：
        //hello
        // world
    }

多行字符

在定義字符串的時候，可以使用 反引號 進(jìn)行包括，這樣就可以進(jìn)行多行字符串的編譯了，例如：

    import "fmt"

    func main() {
        str := `hello world 
    你好，世界`
        fmt.Println(str)
    }
    // 輸出：
    //hello world 
    //你好，世界