Go 数据结构和类型：数组、切片、字典、结构体和指针
Go 语言为开发者提供了多种强大而灵活的数据结构，包括数组、切片、字典、结构体和指针。理解这些基础数据类型的使用方法以及常见的易错点对于编写高效且易维护的 Go 程序非常重要。在本篇文章中，我们将详细讲解这些数据类型的用法，并指出开发中常见的错误。
1. 数组（Array）
数组的定义和使用
数组是 Go 中的一种固定大小的数据类型，能够存储相同类型的元素。数组的大小是固定的，定义时就必须确定，无法动态改变。
package main
import "fmt"
func main() {
// 定义一个长度为 5 的整数数组
var arr [5]int
arr[0] = 10
arr[1] = 20
arr[2] = 30
arr[3] = 40
arr[4] = 50
// 打印数组
fmt.Println(arr) // 输出：[10 20 30 40 50]
}
常见易错点：
数组的大小是类型的一部分：Go 数组的类型包括了数组的大小，例如 [5]int 和 [6]int 是不同的类型。因此，数组大小一旦确定就无法更改。如果你需要一个动态大小的容器，可以使用切片（slice）。
访问超出数组范围会导致 panic：Go 不会自动检查数组的下标是否越界，访问超出数组长度的元素会导致程序运行时错误（panic）。
2. 切片（Slice）
切片是 Go 中常用的动态数组，它提供了比数组更灵活的功能。切片的长度是可变的，可以使用内建的 append() 函数动态扩展。
切片的定义和使用
package main
import "fmt"
func main() {
// 创建一个长度为 3 的切片
slice := make([]int, 3)
slice[0] = 10
slice[1] = 20
slice[2] = 30
fmt.Println(slice) // 输出：[10 20 30]
// 使用 append 扩展切片
slice = append(slice, 40, 50)
fmt.Println(slice) // 输出：[10 20 30 40 50]
}
数组与切片的区别与相似点
相似点
- 数组和切片都可以存储相同类型的元素。
- 都支持通过索引访问元素。
- 都可以使用
len来获取长度。
区别：
- 大小：数组的大小是固定的，定义时就需要指定数组长度，而切片的大小是动态可变的。切片可以在运行时扩展大小。
- 类型：数组的类型包括了长度信息，例如
[5]int和[6]int是不同的类型；而切片的类型是[]int，没有长度限制，且可以随时变化。 - 内存分配：数组在内存中是连续的且大小固定，而切片是基于数组的动态包装，底层数组的大小可以变化。切片的容量 (
cap) 可能会自动扩展，如果需要，Go 会重新分配一个更大的底层数组来容纳更多的元素。 - 传递方式：数组是按值传递的，意味着将数组传递给函数时会复制整个数组；而切片是引用类型，传递时不会复制底层数据，而是传递对底层数组的引用。
常见易错点：
-
切片和数组的大小差异：
- 切片与数组的主要区别在于大小。数组的大小一旦确定就不能改变，而切片可以动态扩展。如果你使用数组时需要对大小有固定的预期，而切片适用于灵活变化的场景。切片扩展时，Go 会自动根据需要扩展底层数组。
-
切片容量 (
cap) 和长度 (len) 的区别：- 切片有两个属性，
len（长度）表示切片当前的元素个数，而cap（容量）表示切片底层数组的大小。当使用append()函数扩展切片时，如果切片的cap不足，Go 会自动重新分配一个更大的底层数组，并将原数据复制到新的内存空间。
- 切片有两个属性，
-
切片引用共享底层数组：
- 切片是对数组的引用，多个切片可能共享同一个底层数组。如果你修改其中一个切片的内容，可能会影响到其他切片。这是因为切片并不会复制底层数组，而是引用同一块内存。
错误示例：以下代码会产生预期外的结果，因为
s2和s1共享同一个底层数组：
package main
import "fmt"
func main() {
s1 := []int{1, 2, 3, 4}
s2 := s1[:2] // s2 引用 s1 的底层数组
s2[0] = 100
fmt.Println(s1) // 输出：[100 2 3 4]，s1 被修改
fmt.Println(s2) // 输出：[100 2]
}
- 数组传递是按值传递：
当你将一个数组传递给函数时，整个数组会被复制，这可能会导致性能问题，尤其是数组很大时。切片则是引用类型，它只会传递底层数组的引用，而不会复制整个数组。
错误示例：以下代码中，数组的变化不会影响原数组：
package main
import "fmt"
func modifyArray(arr [3]int) {
arr[0] = 100
}
func main() {
arr := [3]int{1, 2, 3}
modifyArray(arr)
fmt.Println(arr) // 输出：[1 2 3]，原数组没有被修改
}
- 小结
数组：大小固定，按值传递，适用于大小已知且不需要动态变化的场景。
切片：大小动态可变，引用类型，适用于需要灵活变化的场景，注意切片共享底层数组的特性。
3. 字典（Map）
map 是 Go 提供的无序的键值对集合，具有快速的查找和删除操作，常用于实现缓存、索引等场景。
字典的定义和使用
package main
import "fmt"
func main() {
// 创建一个空的 map
m := make(map[string]int)
// 向 map 中添加键值对
m["apple"] = 5
m["banana"] = 3
m["cherry"] = 7
// 查找 map 中的值
value, exists := m["banana"]
if exists {
fmt.Println("Banana count:", value) // 输出: Banana count: 3
} else {
fmt.Println("Banana not found")
}
// 删除元素
delete(m, "apple")
fmt.Println(m) // 输出: map[banana:3 cherry:7]
}
常见易错点：
查询值时检查 ok：
访问 map 时需要检查第二个返回值（ok），判断键是否存在。如果键不存在，ok 会是 false，而不是直接返回零值。
错误示例
package main
import "fmt"
func main() {
// 初始化一个 map
m := map[string]int{"apple": 5, "banana": 10}
// 错误的查询方式：没有检查 ok
value := m["orange"] // 错误：此时 value 会是类型的零值（0）
fmt.Println("Orange:", value) // 输出: Orange: 0
}
正确示例：
package main
import "fmt"
func main() {
// 初始化一个 map
m := map[string]int{"apple": 5, "banana": 10}
// 正确的查询方式：检查第二个返回值 ok
value, ok := m["apple"]
if ok {
fmt.Println("Apple exists, value:", value)
} else {
fmt.Println("Apple does not exist.")
}
// 键不存在时
value, ok = m["orange"]
if ok {
fmt.Println("Orange exists, value:", value)
} else {
fmt.Println("Orange does not exist.")
}
}
上面这个例子中，m[“orange”] 返回的是 map 的零值 0，而不是一个明确的“键不存在”的标志。这可能导致误解和错误的逻辑判断，因此在访问 map 时，一定要检查第二个返回值 ok，它能帮助你判断键是否存在。
初始化 map 时需要使用 make：
map 必须在使用之前初始化。你不能直接像数组那样声明一个 nil 的 map 来进行赋值，否则会导致运行时错误。.
错误示例
package main
import "fmt"
func main() {
// 错误示例：没有使用 make 初始化 map
var m map[string]int // 默认为 nil
m["apple"] = 5 // 运行时错误：panic: assignment to entry in nil map
}
正确示例
package main
import "fmt"
func main() {
// 正确的初始化方式：使用 make
m := make(map[string]int)
// 使用 map 时可以直接赋值
m["apple"] = 5
fmt.Println("Apple:", m["apple"])
}
在 map 中插入 nil 键会导致 panic：
你不能在 map 中插入一个 nil 键。虽然 Go 会允许插入 nil 值（即值为 nil），但键不能是 nil。
示例：
package main
import "fmt"
func main() {
m := make(map[string]int)
// 错误示例：插入 nil 键
// m[ nil ] = 10 // 错误，编译时会报错：invalid key type
// 正确的使用
m["apple"] = 5
fmt.Println(m) // 输出: map[apple:5]
}
4. 结构体（Struct）
结构体是 Go 中用于组织不同类型数据的复合类型。通过结构体，可以将多个不同类型的数据组合在一起，形成一个新的复合类型。
结构体的定义和使用
package main
import "fmt"
// 定义一个结构体类型
type Person struct {
Name string
Age int
}
func main() {
// 使用结构体字面量创建一个实例
p := Person{Name: "Alice", Age: 30}
// 访问结构体字段
fmt.Println(p) // 输出: {Alice 30}
fmt.Println(p.Name) // 输出: Alice
fmt.Println(p.Age) // 输出: 30
}
空结构体的特殊用法
空结构体（struct{}）在 Go 中是一个特别的结构体类型，结构体没有任何字段。它的大小为零字节，非常轻量。空结构体通常用于占位、信号传递等场景。
空结构体的典型应用
用于 Channel 通信：常用于 goroutine 之间的同步或信号传递，减少内存开销。
用于表示集合中的唯一存在性：例如，map 的键值类型可以是空结构体，用来表示一个集合的成员而不关心值本身。
package main
import "fmt"
func main() {
// 使用空结构体作为 map 的值，表示集合
set := make(map[string]struct{})
set["apple"] = struct{}{}
set["banana"] = struct{}{}
set["cherry"] = struct{}{}
// 打印集合的成员
fmt.Println(set) // 输出: map[apple:{} banana:{} cherry:{}]
}
常见易错点：
空结构体是零字节：空结构体没有任何字段，因此它占用的内存是零字节。你可以用它来在 map 中表示一个集合的成员，而不需要为每个元素分配额外的内存。
空结构体的指针：空结构体的指针可以作为信号传递，用于在不同的 goroutine 之间传递信号。由于它没有数据，指针本身就足以传递信号。
5. 指针（Pointer）
指针是 Go 中用于引用变量内存地址的类型。指针允许程序间接访问内存地址，适用于修改大数据结构或者在函数之间传递复杂数据时避免拷贝。
指针的定义和使用
package main
import "fmt"
func main() {
// 定义一个整数变量
x := 58
// 获取 x 的指针
p := &x
// 通过指针访问和修改 x 的值
fmt.Println(*p) // 输出: 58
*p = 100
fmt.Println(x) // 输出: 100
}
常见易错点：
指针解引用：通过指针 p 可以访问变量 x 的值。要访问指针指向的值，需要使用 *p 来解引用。直接使用 *p = value 进行赋值时，要确保指针不是 nil，否则会导致运行时错误。
指针的零值：指针的零值是 nil，在使用指针之前一定要确保它已被正确初始化。否则，访问 nil 指针会导致程序崩溃。
总结
在 Go 语言中，数组、切片、字典、结构体和指针是常用的数据结构，每种结构都有其独特的用途和优缺点。掌握它们的正确用法并理解常见的易错点，将帮助你写出更健壮、高效的代码。
数组：固定大小，不支持动态扩展，适用于大小已知的数据集合。
切片：动态大小，适用于需要灵活扩展和调整的集合。
字典（map）：键值对存储，支持快速查找，适用于实现快速索引。
结构体：自定义类型，可以将不同类型的数据组合在一起，适用于表示复杂数据结构。
指针：通过内存地址引用变量，适用于修改大数据结构和避免不必要的拷贝。
在这篇文章中，我详细解释了数组和切片的区别、map 的一些错误示例以及 struct 中空结构体的特殊用法。同时，我也补充了一些底层实现的知识点，帮助读者更好地理解 Go 语言的工作原理。如果你在实际开发中遇到问题，欢迎随时交流！
扫一扫
321
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
