章工运维 章工运维
首页
  • linux
  • windows
  • 中间件
  • 监控
  • 网络
  • 存储
  • 安全
  • 防火墙
  • 数据库
  • 系统
  • docker
  • 运维工具
  • other
  • elk
  • K8S
  • ansible
  • Jenkins
  • GitLabCI_CD
  • 随笔
  • 面试
  • 工具
  • 收藏夹
  • Shell
  • python
  • golang
友链
  • 索引

    • 分类
    • 标签
    • 归档
    • 首页 (opens new window)
    • 关于我 (opens new window)
    • 图床 (opens new window)
    • 评论 (opens new window)
    • 导航栏 (opens new window)
周刊
GitHub (opens new window)

章工运维

业精于勤,荒于嬉
首页
  • linux
  • windows
  • 中间件
  • 监控
  • 网络
  • 存储
  • 安全
  • 防火墙
  • 数据库
  • 系统
  • docker
  • 运维工具
  • other
  • elk
  • K8S
  • ansible
  • Jenkins
  • GitLabCI_CD
  • 随笔
  • 面试
  • 工具
  • 收藏夹
  • Shell
  • python
  • golang
友链
  • 索引

    • 分类
    • 标签
    • 归档
    • 首页 (opens new window)
    • 关于我 (opens new window)
    • 图床 (opens new window)
    • 评论 (opens new window)
    • 导航栏 (opens new window)
周刊
GitHub (opens new window)
  • python

  • shell

  • go

    • go基础

      • 指针
      • 数组
        • 切片
        • 字典
        • 结构体
        • 匿名组合
        • 方法
        • 接口
        • error接口
        • panic使用
      • Init函数和main函数
      • 下划线
      • go报错问题收集
      • Redis和MySQL结合的Web服务示例
      • go定义json数据
      • 使用go和vue编写学生管理系统
      • gin框架探索
    • 编程
    • go
    • go基础
    章工运维
    2024-11-14
    目录

    数组

    在Go语言中,数组是一种固定长度的序列,其中所有元素的类型必须相同。Go的数组是值类型,这意味着在赋值或传递数组时,会复制整个数组。虽然数组在Go中使用较少,但理解其基本用法很有帮助。

    # 1. 数组的声明和初始化

    数组的声明格式为:var arrayName [size]Type。其中size是数组的长度,Type是数组元素的类型。

    var nums [5]int // 声明一个长度为5的整数数组,默认值为0
    fmt.Println(nums) // 输出[0 0 0 0 0]
    
    1
    2

    # 1.1 数组初始化

    可以在声明时初始化数组,使用大括号{}提供初始化值。

    // 方式1:声明时初始化
    nums := [5]int{1, 2, 3, 4, 5}
    fmt.Println(nums) // 输出[1 2 3 4 5]
    
    // 方式2:根据元素数量自动推断长度
    nums := [...]int{10, 20, 30}
    fmt.Println(nums) // 输出[10 20 30]
    
    // 方式3:指定索引位置初始化
    nums := [5]int{0: 1, 2: 3} // 将索引0和索引2位置初始化为1和3,其余元素默认值0
    fmt.Println(nums) // 输出[1 0 3 0 0]
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    # 2. 访问和修改数组元素

    可以使用索引访问和修改数组元素,索引从0开始。

    var nums [3]int
    nums[0] = 100
    nums[1] = 200
    nums[2] = 300
    fmt.Println(nums[1]) // 输出200
    
    1
    2
    3
    4
    5

    # 3. 数组的长度

    可以使用len函数获取数组的长度。

    nums := [...]int{10, 20, 30, 40}
    fmt.Println(len(nums)) // 输出4
    
    1
    2

    # 4. 数组作为函数参数

    在Go中,数组作为函数参数传递时是按值传递,即函数内修改不会影响原数组。如果需要修改数组内容,可以传递数组的指针或使用切片(切片更常用)。

    func modifyArray(arr [3]int) {
        arr[0] = 999
    }
    
    func main() {
        nums := [3]int{1, 2, 3}
        modifyArray(nums)
        fmt.Println(nums) // 输出[1 2 3],原数组未修改
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9

    # 4.1 传递数组指针

    如果希望函数内修改数组内容,传递数组指针即可。

    func modifyArray(arr *[3]int) {
        arr[0] = 999
    }
    
    func main() {
        nums := [3]int{1, 2, 3}
        modifyArray(&nums)
        fmt.Println(nums) // 输出[999 2 3]
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9

    # 5. 遍历数组

    可以使用for循环或for range来遍历数组。

    nums := [5]int{1, 2, 3, 4, 5}
    
    // 方法1:使用传统的for循环
    for i := 0; i < len(nums); i++ {
        fmt.Println(nums[i])
    }
    
    // 方法2:使用for range循环
    for index, value := range nums {
        fmt.Printf("Index: %d, Value: %d\n", index, value)
    }
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    # 6. 多维数组

    Go支持多维数组。声明方式类似于一维数组,将每一维的长度依次写在[]内。

    var matrix [2][3]int // 2行3列的二维数组
    matrix[0][0] = 1
    matrix[1][2] = 5
    fmt.Println(matrix) // 输出[[1 0 0] [0 0 5]]
    
    // 多维数组初始化
    matrix := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    fmt.Println(matrix) // 输出[[1 2 3] [4 5 6]]
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11

    # 7. 使用数组的常见场景

    • 存储固定大小的数据:当数据数量固定且不会改变时,使用数组更直接。
    • 矩阵运算:二维数组在矩阵、图像、表格等数据处理场景中很常见。
    • 数组与切片转换:在需要切片的灵活性时,可以将数组转换为切片来操作。

    # 8. 数组与切片的关系

    数组长度固定,而切片是基于数组的动态结构,长度可以改变。可以通过切片将数组的部分或全部内容暴露出来:

    nums := [5]int{1, 2, 3, 4, 5}
    slice := nums[1:4] // 创建一个切片,包含nums的索引1到索引3的元素
    fmt.Println(slice)  // 输出[2 3 4]
    
    1
    2
    3

    # 总结

    Go语言的数组适用于固定大小的数据存储和矩阵等多维数据结构,但由于其固定长度的特性,实际开发中更多会使用切片。理解数组的基本用法和应用场景,有助于更灵活地选择数据结构。

    微信 支付宝
    上次更新: 2024/11/14, 16:29:25

    ← 指针 切片→

    最近更新
    01
    shell脚本模块集合
    05-13
    02
    生活小技巧(认知版)
    04-29
    03
    生活小技巧(防骗版)
    04-29
    更多文章>
    Theme by Vdoing | Copyright © 2019-2025 | 点击查看十年之约 | 鄂ICP备2024072800号
    • 跟随系统
    • 浅色模式
    • 深色模式
    • 阅读模式