Go语言入门教程之Arrays、Slices、Maps、Range操作简明总结

Hazel

发布时间：2026-10-14| 3人浏览过

原创

本文详细介绍Go语言中常用的四种数据结构：数组（Array）、切片（Slice）、映射（Map）以及遍历方法（Range），通过代码示例讲解其创建、读写、修改及遍历的实际操作。

数组（Arrays）的使用

在Go语言中，数组是一组固定长度的有序元素集合。一旦声明，其长度便不可改变。以下是关于数组的基本操作和多维构建的代码示例：

package main
import "fmt"
func main() {
    // 1. 声明一个长度为5的整型数组，初始值为零值（0）
    var a [5]int
    fmt.Println("emp:", a)

    // 2. 通过索引赋值
    a[4] = 100
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])

    // 3. 获取数组长度
    fmt.Println("len:", len(a))

    // 4. 声明并初始化数组
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)

    // 5. 创建二维数组
    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

运行上述代码将输出：

emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d: [[0 1 2] [1 2 3]]

切片（Slices）的操作

切片是Go中最常用的数据结构之一，相比数组，它提供了更灵活的访问接口和动态大小特性。切片的类型由其包含的元素类型决定，而非长度。

package main
import "fmt"
func main() {
    // 1. 使用make创建长度为3的字符串切片
    s := make([]string, 3)
    fmt.Println("emp:", s)

    // 2. 设置和读取元素
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    // 3. 获取长度
    fmt.Println("len:", len(s))

    // 4. 使用append添加元素
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    // 5. 复制切片
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    // 6. 切片截取操作 [low:high]
    l := s[2:5] // 获取下标2到4的元素
    fmt.Println("sl1:", l)
    l = s[:5]   // 从头截取到第5个元素前
    fmt.Println("sl2:", l)
    l = s[2:]   // 从第2个元素截取到最后
    fmt.Println("sl3:", l)

    // 7. 声明并初始化切片
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    // 8. 多维切片（内层切片长度可以不等）
    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

预期输出结果如下：

emp: [ ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d: [[0] [1 2] [2 3 4]]

映射（Maps）的增删查改

Map是Go语言的关联数据类型，类似于其他语言中的哈希表或字典。它通过键值对存储数据。

package main
import "fmt"
func main() {
    // 1. 使用make创建空Map
    m := make(map[string]int)

    // 2. 设置键值对
    m["k1"] = 7
    m["k2"] = 13
    fmt.Println("map:", m)

    // 3. 根据键获取值
    v1 := m["k1"]
    fmt.Println("v1: ", v1)

    // 4. 获取Map长度
    fmt.Println("len:", len(m))

    // 5. 删除键值对
    delete(m, "k2")
    fmt.Println("map:", m)

    // 6. 检查键是否存在（避免零值歧义）
    _, prs := m["k2"]
    fmt.Println("prs:", prs)

    // 7. 声明并初始化Map
    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

执行上述代码的输出为：

map: map[k1:7 k2:13]
v1: 7
len: 2
map: map[k1:7]
prs: false
map: map[foo:1 bar:2]

Range 遍历操作

Range关键字可用于数组、切片、Map以及字符串等多种数据结构的枚举遍历。

package main
import "fmt"
func main() {
    // 1. 遍历切片求和
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    // 2. 遍历切片获取索引和值
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    // 3. 遍历Map获取键和值
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    // 4. 遍历Unicode字符串
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

该部分代码的运行结果为：