目錄

• 數據類型
  • 指針
  • 結構體
  • 數組
  • 切片
  • 切片的方法
  • 映射
  • 函數閉包
• 結束語

前言： go語言的第三篇文章，主要講述go語言中的數據類型，包括指針，結構體，數組，切片，映射，函數閉包等，每個都提供了示例，可直接運行。

數據類型

指針

指針保存了值的內存地址；

• (* 操作符)表示指針指向的底層值；
• (& 操作符)會生成一個指向其操作數的指針；
  示例：

func testPoint() {
    i := 20
    p := &i
    fmt.Println(*p)
    *p = 1
    fmt.Println(i)
}

解讀：*p 的值為 20 ，i 的值為 1

• 第一個輸出：通過指針 p 讀取 i
• 第二個輸出： 通過指針 p 設置 i

結構體

使用 struct 關鍵字表示一個結構體。
結構體就是一個字段的集合，可以使用.來取值
示例：

/*struct*/
type user struct {
    name string
    age  int
}
func testStruct() {
    x := user{"mingyu", 23}
    fmt.Println("對象", x)
    fmt.Println("姓名", x.name)
    x.name = "xiaona"
    fmt.Println("從新設置姓名", x.name)
    //通過指針訪問
    y := &x
    fmt.Println(*y)
    fmt.Println(y.age)
    //指定屬性賦值
    z := user{age: 11}
    fmt.Println("對象", z)
}
 

數組

類型 [n]T 表示擁有 n 個 T 類型的值的數組。
示例：

//數組
func testArray() {
    arr := [2]int{1, 2}
    fmt.Println("數組", arr)
    //指定下標賦值
    arr[1] = 10
    fmt.Println("數組", arr)
}

切片

切片的感念是基於數組的，通過指定數組的下標，動態獲取數組。
如：arr[1:3] 截取下標為1到3的數據 [下標前算後不算,中間用:分割]：

• [1:3] 下標1到3; [:2]:下標0到2之前；[1:]下標為1。

切片並不存儲任何數據，它只是描述了底層數組中的一段,所以修改切片數據，數組數據也會改變。
切片 s 的長度和容量可通過表達式 len(s) 和 cap(s) 來獲取，零值是 nil。
示例：

//切片
func testSection() {
    arr := [5]int{1, 2, 3, 4, 5}
    fmt.Println("數組", arr)
    simpleArr := arr[1:3]
    fmt.Println("切片", simpleArr)
    simpleArr[1] = 20
    fmt.Println("修改切片後的數組", arr)
}

切片的方法

make：

• make創建切片b := make([]int, 0, 5)
  
• 參數含義： 1.類型，2：len（長度），3：cap（容量）；

append

• 追加切片數組 s = append(s, 2, 3, 4)
• 給切片s尾部追加元素2,3,4

Range

• 用於for循環遍歷切片或映射
• 每次叠代都會返回兩個值：第一個值為當前元素的下標，第二個值為該下標所對應元素的一份副本
  • 可以將下標或值賦予 _ 來忽略它
    • 若你只需要索引，去掉value 的部分即可

示例：

//切片方法
func testSectionFunc() {
    arr := make([]string, 0, 0)
    fmt.Println(len(arr), cap(arr), arr)
    arr = append(arr, "陳", "明羽")
    fmt.Println(len(arr), cap(arr), arr)
    for i, v := range arr {
        fmt.Println(i, v)
    }
    fmt.Println("-----------")
    for _, v := range arr {
        fmt.Println(v)
    }
    fmt.Println("-----------")
    for i := range arr {
        fmt.Println(i)
    }
}

映射

將鍵映射到值，也就是map。
make 函數會返回給定類型的映射，並將其初始化備用。
示例：

//映射
func testMap() {
    m := make(map[string]user)
    m["1號"] = user{
        "明羽", 23,
    }
    fmt.Println(m["1號"])
    //還可以這麽寫，還是覺得這麽寫舒服
    var mor = map[string]user{
        "1號": {
            "明羽", 23,
        },
        "2號": {
            "小娜", 23,
        },
    }
    fmt.Println(mor)
}

相關方法：

• 射 m 中插入或修改元素：m[key] = elem
• 元素：elem = m[key]
• 素：delete(m, key)
• 雙賦值檢測某個鍵是否存在：elem, ok = m[key]
  • 若 key 在 m 中，ok 為 true；否則，ok 為 false。
  • 若 key 不在映射中，那麽 elem 是該映射元素類型的零值
  • 若 elem 或 ok 還未聲明，你可以使用短變量聲明：elem, ok := m[key]

函數閉包

函數可以像值一樣傳遞。
示例：

//函數閉包
func testB() func(int) int {
    x := 10
    return func(a int) int {
        return x + a
    }
}
// c 就是testB返回的方法c(i)就是調到x+a
func testA() {
    c := testB()
    for i := 0; i < 5; i++ {
        fmt.Println(c(i))
    }
}

結束語

初識 go 語言系列

• [x] 初識 go 語言
• [x] 初識 go 語言：語法
• [x] 初識 go 語言：數據類型
• [ ] 初識 go 語言：方法，接口及並發

//x表示以完成

關註公眾號

初識 go 語言：數據類型