ToB企服应用市场:ToB评测及商务社交产业平台

标题: Golang学习笔记_13——数组 [打印本页]
作者: 一给    时间: 2024-12-23 18:34
标题: Golang学习笔记_13——数组
Golang学习笔记_10——Switch
Golang学习笔记_11——指针
Golang学习笔记_12——结构体

  
数组

Go语言中的数组是一种具有固定长度、雷同类型元素的集合。数组的长度是数组类型的一部分，这意味着数组的长度在界说后是固定的，不能改变。
在Go语言中，数组的使用非常底子且重要，特别是在明白切片（slice）和映射（map）等更复杂的数据结构时。
1. 界说

  1. // 数组可以通过显式地指定长度和元素类型来定义
  2. var aar1 [5] int
  4. // 定义时直接初始化数组的元素
  5. var aar2 = [5]int{1, 2, 3, 4, 5}
  7. // 省略数组的长度，编译器会根据提供的初始化值的数量自动推断
  8. var aar3 = [...]int{1, 2, 3, 4}
复制代码
2. 访问和修改

  1. // 修改数组的值
  2. aar1[1] = 10
  4. // 访问数组的第三个元素
  5. value := aar[2]
复制代码
3. 多维数组

  1. var matrix [3][4]int
  2. matrix = [3][4]int{
  3.     {1, 2, 3, 4},
  4.     {5, 6, 7, 8},
  5.     {9, 10, 11, 12},
  6. }
  8. // 访问多维数组
  9. value2 := matrix[1][2]  // 访问第二行第三列的元素
复制代码
4. 计算数组长度

  1. length := len(matrix)
复制代码
5. 数组作为函数参数

将数组作为函数参数传递。传递的是数组的副本，因此函数内部对数组的修改不会影响外部的数组。
  1. func array_demo2(aar [5]int) {
  2.         arr := aar
  3.         for i := 0; i < len(arr); i++ {
  4.                 fmt.Println("Index:", i, "Value:", arr[i])
  5.         }
  6.         aar[2] = 100
  7. }
复制代码
测试方法
  1. func Test_array_demo2(t *testing.T) {
  2.         aarr := [...]int{1, 2, 3, 4, 5}
  3.         array_demo2(aarr)
  4.         fmt.Println(aarr)
  5. }
复制代码
输出结果
  1. === RUN   Test_array_demo2
  2. Index: 0 Value: 1
  3. Index: 1 Value: 2
  4. Index: 2 Value: 3
  5. Index: 3 Value: 4
  6. Index: 4 Value: 5
  7. [1 2 3 4 5]
  8. --- PASS: Test_array_demo2 (9.03s)
  9. PASS
复制代码
6. 遍历

  1. func array_demo3(aar [5]int) {
  2.         arr := aar
  3.         for i := 0; i < len(arr); i++ {
  4.                 fmt.Println("Index:", i, "Value:", arr[i])
  5.         }
  7.         for index, value := range arr {
  8.                 fmt.Println("Index:", index, "Value:", value)
  9.         }
  10. }
复制代码
测试方法
  1. func Test_array_demo3(t *testing.T) {
  2.         aar1 := [5]int{1, 2, 3, 4, 5}
  4.         type args struct {
  5.                 aar [5]int
  6.         }
  7.         tests := []struct {
  8.                 name string
  9.                 args args
  10.         }{
  11.                 {
  12.                         name: "1",
  13.                         args: args{aar: aar1},
  14.                 },
  15.         }
  16.         for _, tt := range tests {
  17.                 t.Run(tt.name, func(t *testing.T) {
  18.                         array_demo3(tt.args.aar)
  19.                 })
  20.         }
  21. }
复制代码
输出结果
  1. === RUN   Test_array_demo3
  2. === RUN   Test_array_demo3/1
  3. Index: 0 Value: 1
  4. Index: 1 Value: 2
  5. Index: 2 Value: 3
  6. Index: 3 Value: 4
  7. Index: 4 Value: 5
  8. Index: 0 Value: 1
  9. Index: 1 Value: 2
  10. Index: 2 Value: 3
  11. Index: 3 Value: 4
  12. Index: 4 Value: 5
  13. --- PASS: Test_array_demo3 (0.00s)
  14.     --- PASS: Test_array_demo3/1 (0.00s)
  15. PASS
复制代码
7. 数组的内存体现

数组在内存中是连续存储的，这意味着数组访问速率非常快。但是，数组的长度是其类型的一部分，因此不同长度的数组是不同类型，不能相互赋值。
源码

  1. // array_demo.go 文件package array_demoimport "fmt"func array_demo1() {        // 数组可以通过显式地指定长度和元素类型来界说        var aar1 [5]int        // 界说时直接初始化数组的元素        var aar2 = [5]int{1, 2, 3, 4, 5}        // 省略数组的长度，编译器会根据提供的初始化值的数量自动推断        var aar3 = [...]int{1, 2, 3, 4}        // 修改数组的值        aar1[1] = 10        // 访问数组的第三个元素        value := aar2[2]        fmt.Println(aar3)        fmt.Printf("aar2[2] value is %d\n", value)        var matrix [3][4]int        matrix = [3][4]int{                {1, 2, 3, 4},                {5, 6, 7, 8},                {9, 10, 11, 12},        }        // 访问多维数组        value2 := matrix[1][2] // 访问第二行第三列的元素        fmt.Println(value2)}func array_demo2(aar [5]int) {
  2.         arr := aar
  3.         for i := 0; i < len(arr); i++ {
  4.                 fmt.Println("Index:", i, "Value:", arr[i])
  5.         }
  6.         aar[2] = 100
  7. }
  8. func array_demo3(aar [5]int) {
  9.         arr := aar
  10.         for i := 0; i < len(arr); i++ {
  11.                 fmt.Println("Index:", i, "Value:", arr[i])
  12.         }
  14.         for index, value := range arr {
  15.                 fmt.Println("Index:", index, "Value:", value)
  16.         }
  17. }
复制代码
  1. // array_demo_test.gopackage array_demoimport (        "fmt"        "testing")func Test_array_demo2(t *testing.T) {
  2.         aarr := [...]int{1, 2, 3, 4, 5}
  3.         array_demo2(aarr)
  4.         fmt.Println(aarr)
  5. }
  6. func Test_array_demo3(t *testing.T) {
  7.         aar1 := [5]int{1, 2, 3, 4, 5}
  9.         type args struct {
  10.                 aar [5]int
  11.         }
  12.         tests := []struct {
  13.                 name string
  14.                 args args
  15.         }{
  16.                 {
  17.                         name: "1",
  18.                         args: args{aar: aar1},
  19.                 },
  20.         }
  21.         for _, tt := range tests {
  22.                 t.Run(tt.name, func(t *testing.T) {
  23.                         array_demo3(tt.args.aar)
  24.                 })
  25.         }
  26. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4