Go 語言數(shù)據(jù)類型包含基礎(chǔ)類型和復(fù)合類型兩大類。
基礎(chǔ)數(shù)據(jù)類型包括：布爾型岳枷、整型芒填、浮點(diǎn)型、復(fù)數(shù)型空繁、字符型殿衰、字符串型、錯(cuò)誤類型盛泡。
復(fù)合數(shù)據(jù)類型包括：指針闷祥、數(shù)組、切片傲诵、字典凯砍、通道、結(jié)構(gòu)體拴竹、接口悟衩。

Go 語言在聲明變量時(shí)會(huì)默認(rèn)給變量賦個(gè)當(dāng)前類型的空值，聲明變量的方式：

一幕与、布爾類型 (bool)
值：true 和 false挑势，默認(rèn)值為 false

package main

import "fmt"

func main() {
    var v1, v2 bool         // 聲明變量，默認(rèn)值為 false
    v1 = true               // 賦值
    v3, v4 := false, true   // 聲明并賦值

    fmt.Print("v1:", v1)   // v1 輸出 true
    fmt.Print("\nv2:", v2) // v2 沒有重新賦值纽门，顯示默認(rèn)值：false
    fmt.Print("\nv3:", v3) // v3 false
    fmt.Print("\nv4:", v4) // v4 true
}

二薛耻、數(shù)字類型
數(shù)字類型比較多，默認(rèn)值都是 0赏陵。定義int類型時(shí)饼齿，默認(rèn)根據(jù)系統(tǒng)類型設(shè)置取值范圍，32位系統(tǒng)與int32的值范圍相同蝙搔，64位系統(tǒng)與int64的值范圍相同缕溉。見下表：

package main

import "fmt"

func main() {
    // 無符號(hào)整形鸟蜡，默認(rèn)值都是0
    var u8 uint8
    var u16 uint16
    var u32 uint32
    var u64 uint64
    fmt.Printf("u8: %d, u16: %d, u32: %d, u64: %d\n", u8, u16, u32, u64) // 默認(rèn)值都為0
    u8 = 255
    u16 = 65535
    u32 = 4294967295
    u64 = 18446744073709551615
    fmt.Printf("u8: %d, u16: %d, u32: %d, u64: %d\n", u8, u16, u32, u64)

    // 整型
    var i8 int8
    var i16 int16
    var i32 int32
    var i64 int64
    fmt.Printf("i8: %d, i16: %d, i32: %d, i64: %d\n", i8, i16, i32, i64) // 默認(rèn)值都為0
    i8 = 127
    i16 = 32767
    i32 = 2147483647
    i64 = 9223372036854775807
    fmt.Printf("i8: %d, i16: %d, i32: %d, i64: %d\n", i8, i16, i32, i64)

    // int 型膜赃，取值范圍32位系統(tǒng)為 int32，64位系統(tǒng)為 int64揉忘，取值相同但為不同類型
    var i int
    //i = i32 // 報(bào)錯(cuò)跳座，編譯不通過，類型不同
    //i = i64 // 報(bào)錯(cuò)泣矛，編譯不通過疲眷，類型不同
    i = -9223372036854775808
    fmt.Println("i: ", i)

    // 浮點(diǎn)型，f32精度6位小數(shù)您朽，f64位精度15位小數(shù)
    var f32 float32
    var f64 float64
    fmt.Printf("f32: %f, f64: %f\n", f32, f64) // 默認(rèn)值都為 0.000000
    f32 = 1.12345678
    f64 = 1.12345678901234567
    fmt.Printf("f32: %v, f64: %v\n", f32, f64) // 末位四舍五入狂丝，輸出：f32: 1.1234568, f64: 1.1234567890123457

    // 復(fù)數(shù)型
    var c64 complex64
    var c128 complex128
    fmt.Printf("c64: %v, c128: %v\n", c64, c128) // 實(shí)數(shù)、虛數(shù)的默認(rèn)值都為0
    c64 = 1.12345678 + 1.12345678i
    c128 = 2.1234567890123456 + 2.1234567890123456i
    fmt.Printf("c64: %v, c128: %v\n", c64, c128) // 輸出：c64: (1.1234568+1.1234568i), c128: (2.1234567890123457+2.1234567890123457i)

    // 字符型
    var b byte                                       // uint8 別名
    var r1, r2 rune                                  // uint16 別名
    fmt.Printf("b: %v, r1: %v, r2: %v\n", b, r1, r2) // 默認(rèn)值為0
    b = 'a'
    r1 = 'b'
    r2 = '字'
    fmt.Printf("b: %v, r1: %v, r2: %v\n", b, r1, r2) // 輸出：b: 97(ASCII表示的數(shù)), r1: 98(utf-8表示的數(shù)), r2: 23383 (utf-8表示的數(shù))

    b = u8
    r1 = i32
    fmt.Printf("b: %v, r1: %v\n", b, r1) // 輸出：b: 255, r1: 2147483647

    // 指針地址
    var p uintptr
    fmt.Printf("p: %v\n", p) // 默認(rèn)值為0
    p = 18446744073709551615 // 64位系統(tǒng)最大值
    //p = 18446744073709551616 // 報(bào)錯(cuò)：超出最大值
    fmt.Printf("p: %v\n", p)

}

三虚倒、字符串 (string)
Go 語言默認(rèn)編碼都是 UTF-8美侦。

package main

import "fmt"

func main() {
    var str1 string // 默認(rèn)值為空字符串 ""
    str1 = `hello world`
    str2 := "你好世界"

    str := str1 + " " + str2 // 字符串連接
    fmt.Println(str1)
    fmt.Println(str2)
    fmt.Println(str) // 輸出：hello world 你好世界

    // 遍歷字符串
    l := len(str)
    for i := 0; i < l; i++ {
        chr := str[i]
        fmt.Println(i, chr) // 輸出字符對(duì)應(yīng)的編碼數(shù)字
    }
}

四、指針（pointer）
指針其實(shí)就是指向一個(gè)對(duì)象（任何一種類型數(shù)據(jù)魂奥、包括指針本身）的地址值菠剩，對(duì)指針的操作都會(huì)映射到指針?biāo)傅膶?duì)象上。

package main

import (
    "fmt"
)

func main() {
    var p *int // 定義指向int型的指針耻煤，默認(rèn)值為空：nil

    // nil指針不指向任何有效存儲(chǔ)地址具壮，操作系統(tǒng)默認(rèn)不能訪問
    //fmt.Printf("%x\n", *p) // 編譯報(bào)錯(cuò)

    var a int = 10
    p = &a        // 取地址
    add := a + *p // 取值

    fmt.Println(a)   // 輸出：10
    fmt.Println(p)   // 輸出：0xc0420080b8
    fmt.Println(add) // 輸出：20
}

五、數(shù)組（array）
數(shù)組為一組相同數(shù)據(jù)類型數(shù)據(jù)的集合哈蝇，數(shù)組定義后大小固定棺妓，不能更改，每個(gè)元素稱為element炮赦，聲明的數(shù)組元素默認(rèn)值都是對(duì)應(yīng)類型的0值怜跑。而且數(shù)組在Go語言中是一個(gè)值類型（value type），所有值類型變量在賦值和作為參數(shù)傳遞時(shí)都會(huì)產(chǎn)生一次復(fù)制動(dòng)作吠勘，即對(duì)原值的拷貝性芬。

package main

import "fmt"

func main() {
    // 1.聲明后賦值
    // var <數(shù)組名稱> [<數(shù)組長(zhǎng)度>]<數(shù)組元素>
    var arr [2]int   // 數(shù)組元素的默認(rèn)值都是 0
    fmt.Println(arr) // 輸出：[0 0]
    arr[0] = 1
    arr[1] = 2
    fmt.Println(arr) // 輸出：[1 2]

    // 2.聲明并賦值
    // var <數(shù)組名稱> = [<數(shù)組長(zhǎng)度>]<數(shù)組元素>{元素1,元素2,...}
    var intArr = [2]int{1, 2}
    strArr := [3]string{`aa`, `bb`, `cc`}
    fmt.Println(intArr) // 輸出：[1 2]
    fmt.Println(strArr) // 輸出：[aa bb cc]

    // 3.聲明時(shí)不設(shè)定大小破加，賦值后語言本身會(huì)計(jì)算數(shù)組大小
    // var <數(shù)組名稱> [<數(shù)組長(zhǎng)度>]<數(shù)組元素> = [...]<元素類型>{元素1,元素2,...}
    var arr1 = [...]int{1, 2}
    arr2 := [...]int{1, 2, 3}
    fmt.Println(arr1) // 輸出：[1 2]
    fmt.Println(arr2) // 輸出：[1 2 3]
    //arr1[2] = 3 // 編譯報(bào)錯(cuò)揪利，數(shù)組大小已設(shè)定為2

    // 4.聲明時(shí)不設(shè)定大小，賦值時(shí)指定索引
    // var <數(shù)組名稱> [<數(shù)組長(zhǎng)度>]<數(shù)組元素> = [...]<元素類型>{索引1:元素1,索引2:元素2,...}
    var arr3 = [...]int{1: 22, 0: 11, 2: 33}
    arr4 := [...]string{2: "cc", 1: "bb", 0: "aa"}
    fmt.Println(arr3) // 輸出：[11 22 33]
    fmt.Println(arr4) // 輸出：[aa bb cc]

    // 遍歷數(shù)組
    for i := 0; i < len(arr4); i++ {
        v := arr4[i]
        fmt.Printf("i:%d, value:%s\n", i, v)
    }
}

六幸斥、切片（slice）
因?yàn)閿?shù)組的長(zhǎng)度定義后不可修改峭拘，所以需要切片來處理可變長(zhǎng)數(shù)組數(shù)據(jù)俊庇。切片可以看作是一個(gè)可變長(zhǎng)的數(shù)組狮暑，是一個(gè)引用類型。它包含三個(gè)數(shù)據(jù)：1.指向原生數(shù)組的指針辉饱，2.切片中的元素個(gè)數(shù)搬男，3.切片已分配的存儲(chǔ)空間大小
聲明一個(gè)切片，或從數(shù)組中取一段作為切片數(shù)據(jù)：

package main

import "fmt"

func main() {
    var sl []int             // 聲明一個(gè)切片
    sl = append(sl, 1, 2, 3) // 往切片中追加值
    fmt.Println(sl)          // 輸出：[1 2 3]

    var arr = [5]int{1, 2, 3, 4, 5} // 初始化一個(gè)數(shù)組
    var sl1 = arr[0:2]              // 冒號(hào):左邊為起始位（包含起始位數(shù)據(jù)）鞋囊，右邊為結(jié)束位（不包含結(jié)束位數(shù)據(jù)）止后；不填則默認(rèn)為頭或尾
    var sl2 = arr[3:]
    var sl3 = arr[:5]

    fmt.Println(sl1) // 輸出：[1 2]
    fmt.Println(sl2) // 輸出：[4 5]
    fmt.Println(sl3) // 輸出：[1 2 3 4 5]

    sl1 = append(sl1, 11, 22) // 追加元素
    fmt.Println(sl1)          // 輸出：[1 2 11 22]
}

使用make直接創(chuàng)建切片，語法：make([]類型, 大小溜腐，預(yù)留空間大小)，make() 函數(shù)用于聲明slice切片瓜喇、map字典挺益、channel通道。

package main

import "fmt"

func main() {
    var sl1 = make([]int, 5)          // 定義元素個(gè)數(shù)為5的切片
    sl2 := make([]int, 5, 10)         // 定義元素個(gè)數(shù)5的切片乘寒，并預(yù)留10個(gè)元素的存儲(chǔ)空間（預(yù)留空間不知道有什么用望众？）
    sl3 := []string{`aa`, `bb`, `cc`} // 直接創(chuàng)建并初始化包含3個(gè)元素的數(shù)組切片

    fmt.Println(sl1, len(sl1)) // 輸出：[0 0 0 0 0] 5
    fmt.Println(sl2, len(sl2)) // 輸出：[0 0 0 0 0] 5
    fmt.Println(sl3, len(sl3)) // [aa bb cc] 3

    sl1[1] = 1 // 聲明或初始化大小中的數(shù)據(jù)，可以指定賦值
    sl1[4] = 4
    //sl1[5] = 5 // 編譯報(bào)錯(cuò)伞辛，超出定義大小
    sl1 = append(sl1, 5)       // 可以追加元素
    fmt.Println(sl1, len(sl1)) // 輸出：[0 1 0 0 4 5] 6

    sl2[1] = 1
    sl2 = append(sl2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
    fmt.Println(sl2, len(sl2)) // 輸出：[0 1 0 0 0 1 2 3 4 5 6 7 8 9 10 11] 16

    // 遍歷切片
    for i := 0; i < len(sl2); i++ {
        v := sl2[i]
        fmt.Printf("i: %d, value:%d \n", i, v)
    }
}

七烂翰、字典/映射（map）
map 是一種鍵值對(duì)的無序集合，與 slice 類似也是一個(gè)引用類型蚤氏。map 本身其實(shí)是個(gè)指針甘耿，指向內(nèi)存中的某個(gè)空間。
聲明方式與數(shù)組類似竿滨，聲明方式：var 變量名 map[key類型]值類型 或直接使用 make 函數(shù)初始化：make(map[key類型]值類型, 初始空間大小)
其中key值可以是任何可以用==判斷的值類型佳恬，對(duì)應(yīng)的值類型沒有要求。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 聲明后賦值
    var m map[int]string
    fmt.Println(m) // 輸出空的map：map[]
    //m[1] = `aa`    // 向未初始化的map中賦值報(bào)錯(cuò)：panic: assignment to entry in nil map

    // 聲明并初始化于游，初始化使用{} 或 make 函數(shù)（創(chuàng)建類型并分配空間）
    var m1 = map[string]int{}
    var m2 = make(map[string]int)
    m1[`a`] = 11
    m2[`b`] = 22
    fmt.Println(m1) // 輸出：map[a:11]
    fmt.Println(m2) // 輸出：map[b:22]

    // 初始化多個(gè)值
    var m3 = map[string]string{"a": "aaa", "b": "bbb"}
    m3["c"] = "ccc"
    fmt.Println(m3) // 輸出：map[a:aaa b:bbb c:ccc]

    // 刪除 map 中的值
    delete(m3, "a") // 刪除鍵 a 對(duì)應(yīng)的值
    fmt.Println(m3) // 輸出：map[b:bbb c:ccc]

    // 查找 map 中的元素
    v, ok := m3["b"]
    if ok {
        fmt.Println(ok)
        fmt.Println("m3中b的值為：", v) // 輸出：m3中b的值為： bbb
    }
    // 或者
    if v, ok := m3["b"]; ok { // 流程處理后面講
        fmt.Println("m3中b的值為：", v) // 輸出：m3中b的值為： bbb
    }

    fmt.Println(m3["c"]) // 直接取值毁葱，輸出：ccc

    // map 中的值可以是任意類型
    m4 := make(map[string][5]int)
    m4["a"] = [5]int{1, 2, 3, 4, 5}
    m4["b"] = [5]int{11, 22, 33}
    fmt.Println(m4)                // 輸出：map[a:[1 2 3 4 5] b:[11 22 33 0 0]]
    fmt.Println(unsafe.Sizeof(m4)) // 輸出：8，為8個(gè)字節(jié)贰剥，map其實(shí)是個(gè)指針倾剿，指向某個(gè)內(nèi)存空間
}

八、通道（channel）
說到通道 channel蚌成，則必須先了解下 Go 語言的 goroutine 協(xié)程（輕量級(jí)線程）前痘。channel 就是為 goroutine 間通信提供通道。goroutine 是 Go 語言提供的語言級(jí)的協(xié)程笑陈，是對(duì) CPU 線程和調(diào)度器的一套封裝际度。
channel 也是類型相關(guān)的，一個(gè) channel 只能傳遞一種類型的值涵妥。
聲明：var 通道名 chan 通道傳遞值類型 或 make 函數(shù)初始化：make(chan 值類型, 初始存儲(chǔ)空間大小)

package main

import (
    "fmt"
    "time"
)

func main() {
    var ch1 chan int            // 聲明一個(gè)通道
    ch1 = make(chan int)        // 未初始化的通道不能存儲(chǔ)數(shù)據(jù)乖菱，初始化一個(gè)通道
    ch2 := make(chan string, 2) // 聲明并初始化一個(gè)帶緩沖空間的通道

    // 通過匿名函數(shù)向通道中寫入數(shù)據(jù)坡锡，通過 <- 方式寫入
    go func() { ch1 <- 1 }()
    go func() { ch2 <- `a` }()

    v1 := <-ch1 // 從通道中讀取數(shù)據(jù)
    v2 := <-ch2
    fmt.Println(v1) // 輸出：1
    fmt.Println(v2) // 輸出：a

    // 寫入，讀取通道數(shù)據(jù)
    ch3 := make(chan int, 1) // 初始化一個(gè)帶緩沖空間的通道
    go readFromChannel(ch3)
    go writeToChannel(ch3)

    // 主線程休眠1秒窒所，讓出執(zhí)行權(quán)限給子 Go 程鹉勒，即通過 go 開啟的 goroutine，不然主程序會(huì)直接結(jié)束
    time.Sleep(1 * time.Second)
}

func writeToChannel(ch chan int) {
    for i := 1; i < 10; i++ {
        fmt.Println("寫入：", i)
        ch <- i
    }
}

func readFromChannel(ch chan int) {
    for i := 1; i < 10; i++ {
        v := <-ch
        fmt.Println("讀瘸橙　：", v)
    }
}

// ------  輸出：--------
1
a
寫入： 1
寫入： 2
寫入： 3
讀惹荻睢： 1
讀取： 2
讀绕す佟： 3
寫入： 4
寫入： 5
寫入： 6
讀雀埂： 4
讀取： 5
讀绒嗲狻： 6
寫入： 7
寫入： 8
寫入： 9
讀仍宥： 7
讀取： 8
讀壬闫埂： 9

goroutine 和 channel 的詳細(xì)講解待補(bǔ)充悠反。

九、結(jié)構(gòu)體（struct）
結(jié)構(gòu)體是一種聚合的數(shù)據(jù)類型馍佑，是由零個(gè)或多個(gè)任意類型的值聚合成的實(shí)體斋否。每個(gè)值稱為結(jié)構(gòu)體的成員。

package main

import "fmt"

// 定義一個(gè)結(jié)構(gòu)體 person
type person struct {
    name string
    age  int
}

func main() {
    var p person   // 聲明一個(gè) person 類型變量 p
    p.name = "max" // 賦值
    p.age = 12
    fmt.Println(p) // 輸出：{max 12}

    p1 := person{name: "mike", age: 10} // 直接初始化一個(gè) person
    fmt.Println(p1.name)                // 輸出：mike

    p2 := new(person) // new函數(shù)分配一個(gè)指針拭荤，指向 person 類型數(shù)據(jù)
    p2.name = `張三`
    p2.age = 15
    fmt.Println(*p2) // 輸出：{張三 15}
}

十茵臭、接口（interface）
接口用來定義行為。Go 語言不同于面向?qū)ο笳Z言穷劈，沒有類的概念笼恰，也沒有傳統(tǒng)意義上的繼承。Go 語言中的接口歇终，用來定義一個(gè)或一組行為社证，某些對(duì)象實(shí)現(xiàn)了接口定義的行為，則稱這些對(duì)象實(shí)現(xiàn)了（implement）該接口评凝，類型即為該接口類型追葡。
定義接口也是使用 type 關(guān)鍵字，格式為：

// 定義一個(gè)接口
type InterfaceName interface {
    FuncName1(paramList) returnType
    FuncName2(paramList) returnType
    ...
}

實(shí)例：

package main

import (
    "fmt"
    "strconv"
)

// 定義一個(gè) Person 接口
type Person interface {
    Say(s string) string
    Walk(s string) string
}

// 定義一個(gè) Man 結(jié)構(gòu)體
type Man struct {
    Name string
    Age  int
}

// Man 實(shí)現(xiàn) Say 方法
func (m Man) Say(s string) string {
    return s + ", my name is " + m.Name
}

// Man 實(shí)現(xiàn) Walk 方法奕短，strconv.Itoa() 數(shù)字轉(zhuǎn)字符串
func (m Man) Walk(s string) string {
    return "Age: " + strconv.Itoa(m.Age) + " and " + s
}

func main() {
    var m Man       // 聲明一個(gè)類型為 Man 的變量
    m.Name = "Mike" // 賦值
    m.Age = 30
    fmt.Println(m.Say("hello"))    // 輸出：hello, my name is Mike
    fmt.Println(m.Walk("go work")) // 輸出：Age: 30 and go work

    jack := Man{Name: "jack", Age: 25} // 初始化一個(gè) Man 類型數(shù)據(jù)
    fmt.Println(jack.Age)
    fmt.Println(jack.Say("hi")) // 輸出：hi, my name is jack
}

十一宜肉、錯(cuò)誤（error）
error 類型本身是 Go 語言內(nèi)部定義好的一個(gè)接口，接口里定義了一個(gè) Error() 打印錯(cuò)誤信息的方法翎碑，源碼如下：

type error interface {
    Error() string
}

自定義錯(cuò)誤信息：

package main

import (
    "errors"
    "fmt"
)

func main() {
    // 使用 errors 定制錯(cuò)誤信息
    var e error
    e = errors.New("This is a test error")
    fmt.Println(e.Error()) // 輸出：This is a test error

    // 使用 fmt.Errorf() 定制錯(cuò)誤信息
    err := fmt.Errorf("This is another error")
    fmt.Println(err) // 輸出：This is another test error
}