深度剖析Golang中的陣列,字串和切片

2023-09-07 18:00:20

1. 陣列

陣列是 Golang 中的一種基本資料型別，用於儲存固定數量的同型別元素。在 Golang 中，陣列的長度是固定的，並且必須在定義陣列時指定。

1.1 定義陣列

在 Golang 中，可以使用以下語法宣告陣列：

var 陣列名稱 [陣列長度]資料型別

例如，要宣告一個由 5 個整陣列成的陣列，可以使用以下程式碼：

var arr [5]int

上面的程式碼定義了一個名為 arr 的陣列，包含 5 個整數元素。可以使用以下方式初始化陣列中的元素：

arr := [5]int{1, 2, 3, 4, 5}

上面的程式碼定義了一個名為arr的陣列，包含 5 個整數元素。元素的值分別為 1、2、3、4 和 5。

我們也可以在宣告期間為陣列進行初始化，方法是為其元素提供值。例如，要初始化一個由 3 個字串組成的陣列，可以使用以下程式碼：

var names [3]string = [3]string{"Alice", "Bob", "Charlie"}

1.2 存取陣列

可以使用索引運運算元（[]）來存取陣列中的元素。陣列中的第一個元素的索引為 0，最後一個元素的索引為長度 -1。例如，可以使用以下方式存取陣列中的元素：

  arr := [5]int{1, 2, 3, 4, 5}
  fmt.Println(arr[0]) // 輸出1
  fmt.Println(arr[1]) // 輸出2
  fmt.Println(arr[2]) // 輸出3

上面的程式碼輸出了陣列中的前三個元素。

1.3 修改陣列

可以使用以下方式修改陣列中的元素：

  arr := [5]int{1, 2, 3, 4, 5}
  arr[0] = 10
  fmt.Println(arr) // 輸出[10 2 3 4 5]

上面的程式碼將陣列中的第一個元素修改為 10，並輸出了修改後的陣列。

1.4 陣列長度

在 Golang 中，可以使用 len 函數獲取陣列的長度。例如，以下程式碼獲取陣列 arr 的長度：

  arr := [5]int{1, 2, 3, 4, 5}
  length := len(arr)
  fmt.Println(length) // 輸出5

1.5 遍歷陣列

可以使用 for 迴圈遍歷陣列中的元素。例如，以下程式碼遍歷了陣列 arr 中的元素：

  arr := [5]int{1, 2, 3, 4, 5}
  for i := 0; i  lt; len(arr); i++ {
        fmt.Println(arr[i])
  }

上面的程式碼輸出了陣列中的所有元素。

1.6 多維陣列

Golang 還支援多維陣列。以下是一個定義和初始化二維陣列的範例：

  var arr [3][3]int
  arr = [3][3]int{
       {1, 2, 3},
       {4, 5, 6},
       {7, 8, 9},
  }
  fmt.Println(arr)

上面的程式碼定義了一個 3x3 的二維陣列，並初始化了陣列中的所有元素。可以使用以下方式存取陣列中的元素：

  fmt.Println(arr[0][0]) // 輸出1
  fmt.Println(arr[0][1]) // 輸出2
  fmt.Println(arr[1][0]) // 輸出4
  fmt.Println(arr[2][2]) // 輸出9

當我們知道要儲存的元素數量並且在執行時不需要更改陣列的大小時，陣列非常有用。但是，在需要更靈活的資料型別以動態更改其大小時，我們就需要使用切片。

2. 切片

切片是 Golang 中一種靈活的資料結構，用於處理可變長度的元素集合。切片是由底層陣列、長度和容量組成的。切片的長度表示切片中元素的數量，容量表示切片所參照的底層陣列中元素的數量。

2.1 定義切片

切片是建立在陣列之上的動態資料結構。可以使用以下語法宣告切片：

var 切片名稱 []資料型別

例如，要宣告一個整數切片，可以使用以下程式碼：

  var slice []int

上面的程式碼定義了一個名為 slice 的切片，不包含任何元素。

可以使用以下方式初始化切片中的元素：

  slice := []int{1, 2, 3, 4, 5}

上面的程式碼定義了一個名為 slice 的切片，包含 5 個整數元素。元素的值分別為 1、2、3、4 和 5。

2.2 存取切片元素

可以使用以下方式存取切片中的元素：

  slice := []int{1, 2, 3, 4, 5}
  fmt.Println(slice[0]) // 輸出1
  fmt.Println(slice[1]) // 輸出2
  fmt.Println(slice[2]) // 輸出3

上面的程式碼輸出了切片中的前三個元素。

2.3 修改切片元素

可以使用以下方式修改切片中的元素：

  slice := []int{1, 2, 3, 4, 5}
  slice[0] = 10
  fmt.Println(slice) // 輸出[10 2 3 4 5]

上面的程式碼將切片中的第一個元素修改為 10，並輸出了修改後的切片。

2.4 切片長度和容量

可以使用 len 函數獲取切片的長度，使用 cap 函數獲取切片的容量。例如，以下程式碼獲取切片 slice 的長度和容量：

  slice := []int{1, 2, 3, 4, 5}
  length := len(slice)
  capacity := cap(slice)
  fmt.Println(length) // 輸出5
  fmt.Println(capacity) // 輸出5

注意，這裡的容量等於長度，因為我們沒有指定底層陣列的長度。

2.5 向切片中新增元素

可以使用 append 函數向切片中新增元素。例如，以下程式碼向切片 slice 中新增一個元素 6：

  slice := []int{1, 2, 3, 4, 5}
  slice = append(slice, 6)
  fmt.Println(slice) // 輸出[1 2 3 4 5 6]

上面的程式碼將 6 新增到 slice 的末尾。

我們還可以一次性向切片中新增多個元素。例如，要向 “slice” 切片中新增整數 7、8 和 9，可以使用以下程式碼：

  slice = append(slice, 7, 8, 9)

2.6 切片的切片

由於切片是動態的，因此可以輕鬆地將其傳遞給函數，並且不需要指定其大小。這使切片更加強大的一個重要特性是切片表示式。切片表示式是一個從切片中選擇子序列的方法，其語法如下：

切片名稱[開始索引:結束索引]

這將返回一個包含從開始索引到結束索引之間的元素的新切片。例如，要從 “numbers” 切片中選擇索引為 1 到索引為 3 的元素，可以使用以下程式碼：

  var subSlice = numbers[1:4]

注意，切片表示式中的開始索引包含在結果中，但結束索引不包含在結果中。在上面的例子中，結果將包含 “numbers” 切片中的第二、第三和第四個元素。

切片表示式還具有可選引數，它指定切片的最大容量。如果切片表示式為：

切片名稱[開始索引:結束索引:最大容量]

則結果切片的容量將為最大容量-開始索引。這使得可以建立“截斷”的切片，該切片不包含在開始索引和結束索引之間的任何元素，但可以容納其他元素。

2.7 切片排序

Golang 中的 sort 包提供了多種排序演演算法，可以用於對切片進行排序。以下是一個對切片進行排序的範例：

  slice := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
  sort.Ints(slice)
  fmt.Println(slice) // 輸出[1 1 2 3 3 4 5 5 5 6 9]

上面的程式碼使用 Ints 函數對整數切片進行排序，並輸出排序後的結果。

3. 字串

字串是不可變的位元組序列。在 Golang 中，字串是用雙引號括起來的字元序列。例如，以下是一個字串變數的宣告：

  var str string = "hello world"

與陣列和切片不同，字串不是一個內建型別。實際上，字串是由位元組陣列表示的切片。由於字串是不可變的，因此必須使用切片來操作它們。

3.1 存取字串中的字元

要存取字串中的字元，可以使用索引運運算元。例如，以下程式碼將輸出字串 “hello world” 的第一個字元：

  fmt.Println(str[0])

字串中的每個字元都由一個位元組表示。因此，存取字串中的字元將返回該位元組的ASCII碼值。

3.2 字串切片

我們可以使用切片表示式來建立新的字串切片。例如，以下程式碼將建立一個新的字串切片，其中包含字串 “hello world” 的前 5 個字元：

  var subStr = str[:5]

請注意，與切片一樣，開始索引是包含在結果中的，但結束索引不包含在結果中。

3.3 字串操作

Golang 提供了一些內建的字串函數，使字串操作更加方便。以下是其中一些常用的函數：

len()：返回字串的長度
strings.Contains()：檢查字串中是否包含指定的子字串
strings.Replace()：將字串中的指定子字串替換為另一個字串
strings.Split()：將字串拆分為子字串的切片
strings.ToUpper() 和 strings.ToLower()：將字串中的字元轉換為大寫或小寫

例如，以下程式碼使用 “strings.Contains” 函數檢查字串 “hello world” 是否包含子字串 “world”：

  var contains = strings.Contains(str, "world")
  fmt.Println(contains) // 輸出 true

3.4 關於字串的常見問題

在 Golang 中，處理字串時可能會遇到一些常見問題。以下是一些常見問題和解決方法：

3.4.1 如何將字串轉換為整數？

在 Golang 中，可以使用 strconv 包中的 Atoi 函數將字串轉換為整數。例如，以下程式碼將字串 "123" 轉換為整數 123：

  import "strconv"
  str := "123"
  num, err := strconv.Atoi(str)
  if err != nil {
        fmt.Println("轉換錯誤")
  } else {
        fmt.Println(num)
  }

如果字串不能轉換為整數，則 Atoi 函數將返回一個錯誤。

3.4.2 如何將整數轉換為字串？

可以使用 strconv 包中的 Itoa 函數將整數轉換為字串。例如，以下程式碼將整數 123 轉換為字串 "123"：

  import "strconv"
  num := 123
  str := strconv.Itoa(num)
  fmt.Println(str)

3.4.3 如何檢查字串是否為空？

可以使用 len 函數檢查字串是否為空。例如，以下程式碼檢查字串是否為空：

  str := ""
  if len(str) == 0 {
        fmt.Println("字串為空")
  }

3.4.4 如何檢查字串是否包含另一個字串？

可以使用 strings 包中的 Contains 函數檢查一個字串是否包含另一個字串。例如，以下程式碼檢查字串 "hello world" 是否包含字串 "world"：

  import "strings"
  str := "hello world"
  if strings.Contains(str, "world") {
        fmt.Println("包含字串world")
  }

3.4.5 如何比較兩個字串？

可以使用 “==” 運運算元比較兩個字串是否相等。例如，以下程式碼比較字串 "hello" 和字串 "hello"：

  str1 := "hello"
  str2 := "hello"
  if str1 == str2 {
        fmt.Println("字串相等")
  }

3.4.6 如何將字串拆分為子字串？

可以使用 strings 包中的 Split 函數將字串拆分為子字串。例如，以下程式碼將字串 "hello,world" 拆分為 "hello" 和 "world"：

  import "strings"
  str := "hello,world"
  arr := strings.Split(str, ",")
  fmt.Println(arr)

3.4.7 如何將字串轉換為位元組陣列？

可以將字串強制轉換為 []byte 型別，這將返回一個包含字串的位元組陣列。例如，以下程式碼將字串 "hello" 轉換為位元組陣列：

  str := "hello"
  bytes := []byte(str)
  fmt.Println(bytes)

3.4.8 如何將位元組陣列轉換為字串？

可以使用 string 函數將位元組陣列轉換為字串。例如，以下程式碼將位元組陣列 []byte{104, 101, 108, 108, 111} 轉換為字串 "hello"：

  bytes := []byte{104, 101, 108, 108, 111}
  str := string(bytes)
  fmt.Println(str)

4. 總結

陣列、字串和切片是 Golang 中重要的資料結構。陣列是一組固定大小的資料元素的集合，可以直接存取和修改陣列中的元素。字串是一個不可變的位元組序列，可以通過下標存取字串中的位元組。切片是一個動態陣列，可以根據需要動態增加或縮小大小。切片提供了方便的操作函數和語法，例如向切片中新增元素、獲取切片的長度和容量、對切片進行排序等。

在 Golang 中，陣列、字串和切片的使用非常廣泛，因此理解和掌握它們的基本操作和語法非常重要。同時，也需要了解它們在 Golang 中的特點和優勢，例如切片可以避免陣列長度不足或過長的問題，字串可以直接使用Unicode 編碼等。

以上就是深度剖析Golang中的陣列,字串和切片的詳細內容，更多關於Golang陣列字串切片的資料請關注it145.com其它相關文章！