在 Go 和 Rust 这两种现代语言中，数组和动态集合（如切片或 Vec）是处理数据的基础工具。虽然它们都提供了高效的内存访问能力，但设计理念却截然不同：
- Go 更注重灵活性和性能，允许开发者直接操作底层指针和容量。
- Rust 则强调安全性和零成本抽象，通过编译器保障内存安全，避免越界等常见错误。
本文将从数组、切片（Go）与 Vec（Rust）、切片引用（&[T]）出发，深入分析其底层机制与行为差异，并提供完整的可运行代码示例。
📦 一、Go 中的数组与切片
1. Go 数组
Go 的数组是固定长度的数据结构，存储在栈上（除非显式分配到堆），一旦声明长度不可变。
package main
import "fmt"
func main() {
arr := [5]int{1, 2, 3, 4, 5}
fmt.Println("Array:", arr)
fmt.Printf("Length: %d, Size in bytes: %d\n", len(arr), cap(arr))
}
输出：
Array: [1 2 3 4 5]
Length: 5, Size in bytes: 5
⚠️
cap(arr)在 Go 中对数组无效，这里只是说明数组的大小固定。
2. Go 切片（Slice）
Go 的切片是对数组的一层封装，包含三个字段：指向底层数组的指针、当前长度（len）、最大容量（cap）。
package main
import "fmt"
func main() {
// 创建一个底层数组为 [0, 0, 0, 0, 0] 的切片
s := make([]int, 2, 5)
fmt.Printf("Slice s: len=%d cap=%d %v\n", len(s), cap(s), s)
// 修改切片视图
s = s[:4]
fmt.Printf("After s = s[:4]: len=%d cap=%d %v\n", len(s), cap(s), s)
// 再次修改
s = s[2:]
fmt.Printf("After s = s[2:]: len=%d cap=%d %v\n", len(s), cap(s), s)
}
输出：
Slice s: len=2 cap=5 [0 0]
After s = s[:4]: len=4 cap=5 [0 0 0 0]
After s = s[2:]: len=2 cap=3 [0 0]
可以看到，每次切片操作都会影响 len 和 ptr，进而改变 cap。
📦 二、Rust 中的数组与 Vec
1. Rust 数组
Rust 的数组也是固定长度的，但更强调类型安全和边界检查。
fn main() {
let arr: [i32; 5] = [1, 2, 3, 4, 5];
println!("Array: {:?}", arr);
println!("Length: {}", arr.len());
}
输出：
Array: [1, 2, 3, 4, 5]
Length: 5
❗ Rust 不允许你访问超过
.len()的索引，否则会 panic。
2. Rust 向量（Vec）
Vec<T> 是 Rust 的动态数组实现，支持自动扩容和切片操作。
fn main() {
let mut v = Vec::with_capacity(5);
for i in 0..3 {
v.push(i);
}
println!("Vec: {:?}", v);
println!("Len: {}, Capacity: {}", v.len(), v.capacity());
// 切片操作
let slice = &v[..2];
println!("Slice: {:?}", slice);
}
输出：
Vec: [0, 1, 2]
Len: 3, Capacity: 5
Slice: [0, 1]
注意：slice 是一个只读视图，不能直接 push 数据，只能通过原始 Vec 修改内容。
3. Rust 切片引用（&[T]）
Rust 的切片引用类似于 Go 的切片，但它不包含 capacity 字段，只能看到当前可见的范围。
fn main() {
let v = vec![0, 0, 0, 0, 0];
let c = &v[..2]; // len=2
println!("c: {:?}", c);
// 错误：越界访问
let d = &c[2..5]; // panic!
println!("d: {:?}", d);
}
这个例子会在运行时报错：
thread 'main' panicked at 'index 2..5 outside bounds of [..2]'
🔁 三、Go 与 Rust 的核心区别总结
| 特性 | Go | Rust |
|---|---|---|
| 数组是否固定长度 | ✅ 是 | ✅ 是 |
| 是否支持动态数组 | ✅ 切片 + 底层数组 | ✅ Vec |
| 切片是否包含 capacity | ✅ 是 | ❌ 否（只有 Vec 有） |
| 切片是否能访问超出当前 len 的数据 | ✅ 只要不超过 cap | ❌ 不行，panic |
| 是否允许手动管理 ptr/len/cap | ✅ 支持（unsafe） | ❌ 不支持（除非 unsafe） |
| 内存安全性 | ❌ 需要开发者控制 | ✅ 编译器/运行时保障 |
🧩 四、设计哲学对比
| Go | Rust |
|---|---|
| 灵活、高效、适合系统级编程 | 安全、可靠、适合高性能 + 安全并重场景 |
| 切片操作灵活但容易出错 | 切片安全但表达力略逊 |
| 更适合熟悉底层机制的开发者 | 更适合希望专注于逻辑而非细节的开发者 |
🎁 五、延伸实践建议
✅ 1. 手动模拟 Go 的切片结构体（Rust unsafe）
你可以用 Rust 的 unsafe 来模拟 Go 的切片结构体：
use std::slice;
#[repr(C)]
struct MySlice<'a, T> {
data: *const T,
len: usize,
cap: usize,
_marker: std::marker::PhantomData<&'a T>,
}
impl<'a, T> MySlice<'a, T> {
fn from_vec(v: &'a Vec<T>) -> Self {
MySlice {
data: v.as_ptr(),
len: v.len(),
cap: v.capacity(),
_marker: std::marker::PhantomData,
}
}
unsafe fn as_slice(&self) -> &'a [T] {
slice::from_raw_parts(self.data, self.len)
}
unsafe fn slice(&self, start: usize, end: usize) -> &'a [T] {
if end > self.cap {
panic!("Out of capacity");
}
slice::from_raw_parts(self.data.offset(start as isize), end - start)
}
}
fn main() {
let v = vec![1, 2, 3, 4, 5];
let my_slice = MySlice::from_vec(&v);
unsafe {
let s = my_slice.slice(2, 5);
println!("Simulated slice: {:?}", s);
}
}
这个例子展示了如何在 Rust 中模拟 Go 的切片行为，同时保留 capacity 控制。
📝 六、结语
Go 和 Rust 在数组与集合类型的设计上体现了不同的语言哲学：
- Go 的切片 提供了极致的灵活性和性能，但也要求开发者对底层数组的生命周期和容量变化非常敏感。
- Rust 的 Vec 和 &[T] 则以安全为核心，牺牲了一定的灵活性，但极大地降低了出错的可能性。
掌握这两者的区别，有助于你在不同项目中选择合适的语言和数据结构。
📚 延伸阅读推荐
- Go 切片官方文档
- Rust Vec 文档
- Rust Slice 文档
- 《Programming Rust》第 4 章：Vectors and Slices
- 《The Go Programming Language》第 4 章：Composite Types