帶你學夠浪：Go語言基礎系列 - 8分鐘學複合型別

檸檬橙1024發表於2020-06-16
Go型別
★

文章每週持續更新，原創不易，「三連」讓更多人看到是對我最大的肯定。可以微信搜尋公眾號「 後端技術學堂 」第一時間閱讀（一般比部落格早更新一到兩篇）

”

對於一般的語言使用者來說 ，20% 的語言特性就能夠滿足 80% 的使用需求，剩下在使用中掌握。基於這一理論，Go 基礎系列的文章不會刻意追求面面俱到，但該有知識點都會覆蓋，目的是帶你快跑趕上 Golang 這趟新車。

Hurry up , Let's go !

前面我們學習過 Golang 中基礎資料型別，比如內建型別 int string bool 等，其實還有一些複雜一點點，但很好用的複合型別，類似 C 中的陣列和 struct、C++ 中的 map ，今天我們就來學習 Go 中的複合型別。

通過本文的學習你將掌握以下知識：

  • 結構體
  • 指標型別
  • 陣列和切片
  • 對映型別

指標

指標不儲存實際資料的內容，而是儲存了指向值的記憶體地址 。用 & 對變數取記憶體地址，用 * 來訪問指向的記憶體。這點和 C 中的指標是一樣，唯一不同的是 Go 中的指標不能運算。

 a := 3
 pa := &a // 用 `&` 對變數取記憶體地址
 fmt.Println("point", a, *pa) // 用 `*` 來訪問指向的記憶體

只宣告沒賦值的指標值是 nil ，代表空指標。

 var a0 *int // 只宣告沒賦值的指標是nil
 if a0 == nil {
  fmt.Println("point", "it is nil point")
 }

結構體

與C中的結構體類似， 結構體是一種聚合的資料型別，是由零個或多個任意型別的值聚合成的實體。每個值稱為結構體的成員，看例子：

type Test struct {
  a int
  b int
 }

語法上的不同看到了嗎？ 每個結構體欄位之後沒有分號，沒有分號寫起來還是很舒服的。

初始化

可以在定義的時候初始化

test := Test{1, 2}  // 定義結構體變數並初始化

初始化部分結構體欄位

t2  = Test{a: 3}   //指定賦值Test.a為3  Test.b隱式賦值0

隱式初始化

t3  = Test{}       // .a .b都隱式賦值0

多個變數可以分組一起賦值

var (
    t1  = Test{8, 6}
    t2  = Test{a: 3}  //指定賦值Test.a  Test.b隱式賦值0
    t3  = Test{}      // .a .b都隱式賦值0
    pt4 = &Test{8, 6} // 指標
)

訪問成員

通過 . 運算來訪問結構體成員，不區分結構體型別或是結構體指標型別。

fmt.Println("struct", st0.a, st0.b) // 通過 . 運算來訪問結構體成員

對於只宣告沒賦值的結構體，其內部變數被賦予零值，下面我們宣告瞭 st0 但沒有對其賦值。

var st0 Test  
fmt.Println("struct", st0.a, st0.b) //輸出：struct 0 0

陣列

陣列是一個由固定長度的特定型別元素組成的序列，一個陣列可以由零個或多個元素組成。 陣列可以用下標訪問元素，下標從 0 開始。

陣列宣告後賦值

 var strarr [2]string // 陣列宣告語法
 strarr[0] = "ready"
 strarr[1] = "go"

宣告賦值同時完成

 intarr := [5]int{6, 8, 9, 10, 7} // 宣告賦值同時完成

對於確定初始值個數的陣列，可以省略陣列長度

 intarr := [...]int{6, 8, 9, 10, 7} // 宣告賦值同時完成

Slice 切片

切片是變長的序列，序列中每個元素都有相同的型別。slice 語法和陣列很像，只是沒有固定長度而已，切片底層引用一個陣列物件，修改切片會修改原陣列。

通過切片可以訪問陣列的部分或全部元素，正因為切片長度不是固定的，因此切片比陣列更加的常用。

宣告與初始化

常規初始化

簡短宣告並初始化切片

s0 := []int{1, 2, 3, 4, 5, 6} // 簡短宣告加賦值

宣告後再初始化

var s []int        // 宣告切片s
s = s0     // 用切片s0初始化切片s

宣告並初始化切片

var s00 []int = s0 // 用切片s0初始化切片s

切片的零值是 nil

// 切片的零值是nil 空切片長度和容量都是0
var nilslice []int
if nilslice == nil {
    fmt.Println("slice", "nilslice is nil ", len(nilslice), cap(nilslice))
}

make初始化

除了上述的常規初始化方法，還可以用 make 內建函式來建立切片

// 內建函式make建立切片，指定切片長度和容量
// make 函式會分配一個元素為零值的陣列並返回一個引用了它的切片
s2 := make([]int, 4, 6) //建立元素都是0的切片s2, 長度為4，容量為6 第三個引數可以省略
fmt.Println("slice", len(s2), cap(s2), s2)

切片長度

長度表示切片中元素的數目，可用內建函式 len 函式得到。

切片容量

容量表示切片中第一個元素到引用的底層陣列結尾所包含元素個數，可用內建函式 cap 求得。

切片區間

切片區間遵循「左閉右開」原則，

s0 := [5]int{6, 8, 9, 10, 7} // 陣列定義
var slice []int = intarr[1:4]    //  建立切片slice 包含陣列子序列

預設上下界。切片下界的預設值為 0，上界預設是該切片的長度。

fmt.Println("slice", s0[:], s0[0:], s0[:5], s0[0:5]) // 這四個切片相同

切片append操作

append 函式用於在切片末尾追加新元素。

新增元素也分兩種情況。

新增之後長度還在原切片容量範圍內

s2 := make([]int, 4, 6) //建立元素都是0的切片s2, 長度為4，容量為6 第三個引數可以省略
s22 := append(s2, 2)    // append每次都是在最後新增，所以此時，s21 s22指向同一個底層陣列
fmt.Println(s21, s22)   // [0 0 0 0 2] [0 0 0 0 2]

新增元素之後長度超出原切片容量

此時會分配新的陣列空間，並返回指向這個新分配的陣列的切片。

下面例子中 s24 切片已經指向新分配的陣列，s22 依然指向的是原來的陣列空間，而 s24 已經指向了新的底層陣列。

 s24 := append(s2, 1, 2, 3)
 fmt.Println(s24, s22) // s24 [0 0 0 0 1 2 3] [0 0 0 0 2]

二維切片

可以定義切片的切片，類似其他語言中的二維陣列用法。參考程式碼：

 s3 := [][]int{
  {1, 1, 1},
  {2, 2, 2},
 }
 fmt.Println(s3, s3[0], len(s3), cap(s3)) // 輸出： [[1 1 1] [2 2 2]] [1 1 1] 2 2

map 對映型別

在 Go 中 map 是鍵值對型別，代表 key 和value 的對映關係，一個map就是一個雜湊表的引用 。

定義和初始化

下面這樣定義並初始化一個 map 變數

 m0 := map[int]string{
  0: "0",
  1: "1",
 }

也可以用內建 make 函式來初始化一個 map 變數，後續再向其中新增鍵值對。像下面這樣：

 m1 := make(map[int]string) // make 函式會返回給定型別的對映，並將其初始化備用
 if m1 != nil {
  fmt.Println("map", "m1 is not nil", m1) // m1 不是nil
 }
 m1[0] = "1"
 m1[1] = "2"

注意：只宣告不初始化的map變數是 nil 對映，不能直接拿來用！

 var m map[int]string // 未初始化的m零值是nil對映
 if m == nil {
  fmt.Println("map", "m is nil", m)
 }
 //m[0] = "1" // 這句引發panic異常， 對映的零值為 nil 。nil對映既沒有鍵，也不能新增鍵。

元素讀取

使用語法：vaule= m[key] 獲取鍵 key 對應的元素 vaule 。

上面我們只用了一個變數來獲取元素，其實這個操作會返回兩個值，第一個返回值代表讀書的元素，第二個返回值是代表鍵是否存在的 bool 型別，舉例說明：

 v, st := m1[0]  // v是元素值，下標對應的元素存在st=true 否則st=false
 _, st1 := m1[0] // _ 符號表示忽略第一個元素
 v1, _ := m1[0]  // _ 符號表示忽略第二個元素 
 fmt.Println(v, st, v1, st1, m1[2]) // m1[2]不存在，返回元素string的零值「空字元」

刪除元素

內建函式 delete 可以刪除 map 元素，舉例：

delete(m1, 1)  // 刪除鍵是 1 的元素

range 遍歷

range 用於遍歷 切片 或 對映。

陣列或切片遍歷

當使用for 迴圈和 range 遍歷陣列或切片時，每次迭代都會返回兩個值。第一個值為當前元素的下標，第二個值為該下標所對應元素的一份副本。

s1 := []int{1, 2, 3, 4, 5, 6}  
for key, vaule := range s1 {
    fmt.Println("range", key, vaule)
}

for key := range s1 { // 只需要索引，忽略第二個變數即可
    fmt.Println("range", key)
}

for _, vaule := range s1 { // 只需要元素值，用'_'忽略索引
    fmt.Println("range", vaule)
}

map 遍歷

當使用for 迴圈和 range 遍歷map 時，每次迭代都會返回兩個值。第一個值為當前元素 key ， 第二個值是 value。

m0 := map[int]string{
    0: "0",
    1: "1",
}
fmt.Println("map", m0)

for k, v := range m0 { // range遍歷對映，返回key 和 vaule
    fmt.Println("map", "m0 key:", k, "vaule:", v)
}

總結

通過本文的學習，我們掌握了 Golang 中基本的控制流語句，利用這些控制語句加上一節介紹的變數等基礎知識，可以構成豐富的程式邏輯，你就能用 Golang 來做一些有意思的事情了。

感謝各位的閱讀，文章的目的是分享對知識的理解，技術類文章我都會反覆求證以求最大程度保證準確性，若文中出現明顯紕漏也歡迎指出，我們一起在探討中學習.

今天的技術分享就到這裡，我們下期再見。

創作不易，白票不是好習慣，如果在我這有收穫，動動手指「點贊」「關注」是對我持續創作的最大支援。

★

可以微信搜尋公眾號「 後端技術學堂 」回覆「資料」「1024」有我給你準備的各種程式設計學習資料。文章每週持續更新，我們下期見！

”

本文使用 mdnice 排版

相關文章