1 简介

数组和切片在go语言中是非常常见的两个数据类型。数组和切片都用于存储相同类型的元素集合。但是，它们在行为和使用案例方面存在显著差异。

数组的大小是固定的，而切片是动态的，更灵活。了解数组和切片之间的差异对于编写高效且可维护的 Go 程序至关重要。

2 数组和切片的区别示例

声明、初始化和使用数组的示例：

• 使用场景

使用数组：当集合的大小是固定的并且在编译时已知时。
使用切片：当集合的大小需要在运行时动态更改时。

按值传递：数组按值传递给函数，而切片按引用传递。
灵活性：切片提供了更大的灵活性，并广泛用于 Go 编程。

  func main() {
      // Declare and initialize an array
      var arr [3]int = [3]int{1, 2, 3}

      // Print the array
      fmt.Println("Array:", arr)

      // Access elements by index
      fmt.Println("First Element:", arr[0])

      // Update an element
      arr[1] = 10
      fmt.Println("Updated Array:", arr)
  }

声明和初始化：数组声明为固定大小 3 并初始化为 values 。arr{1, 2, 3}
访问元素：使用从零开始的索引来访问元素。
更新元素：第二个元素的值将更新为10 。

输出：

    Array: [1 2 3]
    First Element: 1
    Update Array:[1 10  3]

3 切片示例

下面是声明、初始化和使用切片的示例：

  func main() {
      // Declare and initialize a slice
      var s []int = []int{1, 2, 3}

      // Print the slice
      fmt.Println("Slice:", s)

      // Append an element
      s = append(s, 4)
      fmt.Println("Slice after append:", s)

      // Access and update elements
      s[1] = 10
      fmt.Println("Updated Slice:", s)
  }

解释

声明和初始化：s{1, 2, 3}切片使用 values 声明和初始化。
动态调整大小：该append函数用于将元素添加到切片中。
访问和更新：可以像数组一样访问和更新元素。

输出：

Slice : [1 2 3]
Slice after append: [1 2 3 4]
Update Slice  [1 10 3 4]

4 字符串与数组和切片之间的转换

从字符串转换为字节切片，string -> []byte：

func ChangeStringToSlice() {

str := "this is test"
b1 := []byte(str)
fmt.Printf("type of b1:%T type of str:%T \n", b1, str)
fmt.Println(str, b1)
}

要将数组转换为切片，请[20]byte -> []byte：

	func ChangeArrayToSlice() {
    arr := [3]string{"1", "a", "c3"}
    ss1 := make([]int, 10)
    strings := []string{"shark", "cuttlefish", "squid", "mantis shrimp"}
    slices := arr[:]
    fmt.Printf("type of arr:%T type of slices:%T ss1:%T  strings:%T\n", arr, slices, ss1, strings)
    fmt.Println(arr, slices)
    }

要将字符串复制到数组中，请执行以下操作 string -> [20]byte：

func CopyStringToArray() {
    strJson := "{\"user\": \"postgre\",\"password\": \"postgre.2022\"}"
    var arr2 = []byte(strJson)
    var arr21 [20]byte
    copy(arr21[:], "{\"user\": \"postgre\",\"password\": \"postgre.2022\"}")
    fmt.Printf("type of arr2:%T, %s \n", arr2, arr2)
    fmt.Println(arr2, arr21)
}

与上面相同，但首先将字符串显式转换为切片：

func ChangeStringToSliceToArray{
    var arr3 [30]byte
    copy(arr3[:], []byte(str))
    fmt.Printf("type of arr3:%T", arr3)
    fmt.Println(arr3)
}

• 要点：

内置函数仅从切片copy复制到切片。
数组是“底层数据”，而切片是“底层数据的视口”。

Using[:]使数组符合切片的条件。
字符串不符合 复制到的切片，但可以复制（字符串是不可变的）切片。

如果字符串太长，copy将只复制适合的部分字符串（然后可能只复制部分多字节符文，这将破坏结果字符串的最后一个符文）。

5 小结

数组和切片之间的主要区别：

  特征	数组					切片
  大小	在声明时固定			动态的，可以增长和收缩
  声明	var arr [3]int			var s []int
  调整	无法调整大小			可以动态调整大小
  内存	在编译时分配			在运行时分配
  默认值	所有元素的值均为零		nil，如果未初始化
  性能	快速，因为大小是固定的	由于动态调整大小，速度略慢
  用例	静态集合				动态管理

使用场景：

使用数组：当集合的大小是固定的并且在编译时已知时。
使用切片：当集合的大小需要在运行时动态更改时。

按值传递：数组按值传递给函数，而切片按引用传递。
灵活性：切片提供了更大的灵活性，并广泛用于 Go 编程。