- 引言 (Introduction)
背景： 在 Go 1.18 引入泛型之前，实现通用数据结构通常需要使用 interface{} (或 any)，这会导致运行时类型断言的性能开销以及失去编译期类型检查保护。
目标： 本文将通过实现一个单向链表（Singly Linked List），展示如何利用 Go 泛型编写复用性强、类型安全且高效的数据结构。
核心亮点：
类型安全：编译期确定节点存储的类型。
函数式编程风格：支持 Map、Filter、Iterate 等高阶操作。
健壮性处理：完善的空指针（nil）安全检查。运行结果，如图1
Go
package main
import "fmt"
// List 表示一个单向链表，可以存储任意类型的值
type List[T any] struct {
next *List[T]
val T
}
// New 创建一个包含给定值的新链表节点
// 参数:
// - val: 存储在链表节点中的初始值
//
// 返回值:
// - 指向新创建的包含该值的链表的指针
func New[T any](val T) *List[T] {
return &List[T]{val: val}
}
// Append 在链表末尾添加一个新元素
// 参数:
// - val: 要追加到链表的值
func (l *List[T]) Append(val T) {
current := l
for current.next != nil {
current = current.next
}
current.next = &List[T]{val: val}
}
// Prepend 在链表开头添加一个新元素
// 参数:
// - val: 要前置到链表的值
//
// 返回值:
// - 指向新链表头节点的指针，包含前置的值
func (l *List[T]) Prepend(val T) *List[T] {
return &List[T]{
val: val,
next: l,
}
}
// Length 返回链表中的元素数量
// 返回值:
// - 链表中节点的总数
func (l *List[T]) Length() int {
if l == nil {
return 0
}
count := 0
current := l
for current != nil {
count++
current = current.next
}
return count
}
// ToSlice 将链表转换为切片
// 返回值:
// - 包含链表中所有元素的切片
func (l *List[T]) ToSlice() []T {
if l == nil {
return []T{}
}
result := make([]T, 0, l.Length())
current := l
for current != nil {
result = append(result, current.val)
current = current.next
}
return result
}
// Iterate 对链表中的每个元素应用给定的函数
// 参数:
// - fn: 要应用于每个元素的函数
func (l *List[T]) Iterate(fn func(T)) {
if l == nil {
return
}
current := l
for current != nil {
fn(current.val)
current = current.next
}
}
// Map 通过对每个元素应用函数来创建一个新的链表
// 参数:
// - l: 原始链表
// - fn: 转换函数，将类型 T 转换为类型 U
//
// 返回值:
// - 包含转换后元素的新链表
func Map[T, U any](l *List[T], fn func(T) U) *List[U] {
if l == nil {
return nil
}
newHead := New(fn(l.val))
currentNew := newHead
currentOld := l.next
for currentOld != nil {
currentNew.next = New(fn(currentOld.val))
currentNew = currentNew.next
currentOld = currentOld.next
}
return newHead
}
// Filter 创建一个只包含满足谓词条件的元素的新链表
// 参数:
// - predicate: 判断函数，返回 true 表示保留该元素
//
// 返回值:
// - 包含满足条件元素的新链表
func (l *List[T]) Filter(predicate func(T) bool) *List[T] {
if l == nil {
return nil
}
var newHead *List[T]
var currentNew *List[T]
current := l
for current != nil {
if predicate(current.val) {
if newHead == nil {
newHead = New(current.val)
currentNew = newHead
} else {
currentNew.next = New(current.val)
currentNew = currentNew.next
}
}
current = current.next
}
return newHead
}
// Contains 检查链表是否包含给定的值
// 参数:
// - l: 要搜索的链表
// - val: 要查找的值
//
// 返回值:
// - 如果找到值则返回 true，否则返回 false
func Contains[T comparable](l *List[T], val T) bool {
_, found := Find(l, val)
return found
}
// Find 返回值的第一次出现位置及其索引，如果未找到则返回 -1
// 参数:
// - l: 要搜索的链表
// - val: 要查找的值
//
// 返回值:
// - int: 元素的索引位置，未找到时返回 -1
// - bool: 如果找到值则返回 true，否则返回 false
func Find[T comparable](l *List[T], val T) (int, bool) {
if l == nil {
return -1, false
}
current := l
index := 0
for current != nil {
if current.val == val {
return index, true
}
current = current.next
index++
}
return -1, false
}
// Delete 从链表中删除第一次出现的指定值
// 参数:
// - l: 要操作的链表
// - val: 要删除的值
//
// 返回值:
// - *List[T]: 删除后的新链表头节点
// - bool: 如果找到并删除了值则返回 true，否则返回 false
func Delete[T comparable](l *List[T], val T) (*List[T], bool) {
if l == nil {
return nil, false
}
if l.val == val {
return l.next, true
}
current := l
for current.next != nil {
if current.next.val == val {
current.next = current.next.next
return l, true
}
current = current.next
}
return l, false
}
func main() {
// 创建整数链表
intList := New(10)
intList.Append(20)
intList.Append(30)
intList.Append(40)
fmt.Println("Integer List:", intList.ToSlice())
fmt.Println("Length:", intList.Length())
// 测试 Contains 方法
fmt.Println("Contains 20:", Contains(intList, 20))
fmt.Println("Contains 50:", Contains(intList, 50))
// 测试 Find 方法
if idx, found := Find(intList, 30); found {
fmt.Printf("Found 30 at index %d\n", idx)
}
// 测试 Prepend 方法
intList = intList.Prepend(5)
fmt.Println("After prepend 5:", intList.ToSlice())
// 测试 Delete 方法
intList, deleted := Delete(intList, 20)
fmt.Printf("Deleted 20: %v, List: %v\n", deleted, intList.ToSlice())
// 测试 Iterate 方法
fmt.Print("Iterate: ")
intList.Iterate(func(val int) {
fmt.Printf("%d ", val)
})
fmt.Println()
// 测试 Map 方法
doubled := Map(intList, func(x int) int {
return x * 2
})
fmt.Println("Doubled:", doubled.ToSlice())
// 测试 Filter 方法
evens := intList.Filter(func(x int) bool {
return x%2 == 0
})
fmt.Println("Even numbers:", evens.ToSlice())
// 创建字符串链表
strList := New("hello")
strList.Append("world")
strList.Append("go")
fmt.Println("\nString list:", strList.ToSlice())
fmt.Println("Length:", strList.Length())
fmt.Println("Contains 'world':", Contains(strList, "world"))
}
Plaintext
/app/go-tour/list # go run main.go
Integer List: [10 20 30 40]
Length: 4
Contains 20: true
Contains 50: false
Found 30 at index 2
After prepend 5: [5 10 20 30 40]
Deleted 20: true, List: [5 10 30 40]
Iterate: 5 10 30 40
Doubled: [10 20 60 80]
Even numbers: [10 30 40]
String list: [hello world go]
Length: 3
Contains 'world': true
/app/go-tour/list # - 核心结构设计 (Core Structure)
节点定义：
Go
type List[T any] struct {
next *List[T]
val T
}解释 T any 约束：允许存储任意类型。
解释单向链表的指针结构。
构造函数 New：
展示如何初始化一个泛型节点。
- 基础操作实现 (Basic Operations)
追加元素 (Append)：
遍历到尾部并插入新节点。
注意： 时间复杂度 O(N)。
前置元素 (Prepend)：
创建新节点指向当前头节点。
优势： 时间复杂度 O(1)，是链表的高效操作。
获取长度 (Length)：
遍历计数。
优化点： 增加 nil 检查，防止对空链表调用时 panic。 - 高级功能与函数式编程 (Advanced & Functional Style)
转换为切片 (ToSlice)：
方便与 Go 标准库交互。
性能探讨： 预分配容量 vs 动态 append。
迭代器 (Iterate)：
接受一个函数 func(T)，对每个元素执行操作。
解耦遍历逻辑与业务逻辑。
映射 (Map)：
签名：func Map[T, U any](l *List[T], fn func(T) U) *List[U]
展示多类型参数泛型：将 List[int] 转换为 List[string] 等。
过滤 (Filter)：
根据谓词函数保留满足条件的元素，返回新链表。 - 搜索与修改 (Search & Modification)
包含判断 (Contains) 与查找 (Find)：
使用 comparable 约束：func ContainsT comparable。
解释为什么搜索需要类型可比较。
代码复用：Contains 内部调用 Find。
删除元素 (Delete)：
处理头节点删除的特殊情况。
处理中间/尾部节点删除。
关键修复： 必须检查输入链表是否为 nil，避免运行时崩溃。 - 代码健壮性与最佳实践 (Robustness & Best Practices)
Nil 安全：
在所有方法入口处检查 if l == nil。
对比未加检查前的潜在 Panic 风险。
内存管理：
Go 的 GC 会自动处理不再引用的节点，但在删除操作中切断指针 (current.next = current.next.next) 有助于 GC 更快回收内存。 - 完整示例与测试 (Example Usage)
展示 main 函数中的综合用例：
整数链表的操作。
字符串链表的操作。
链式调用演示。 - 总结 (Conclusion)
泛型让 Go 的集合类库编写变得更加优雅和安全。
虽然链表在 Go 中不如 Slice 常用，但作为学习泛型约束（any vs comparable）和多类型参数（Map）的载体非常合适。
未来展望：可以进一步扩展为双向链表或并发安全链表。
需要长期技术维护或远程问题排查？
我是拥有 15+ 年经验的 PHP / Go 后端工程师，长期关注已有系统维护、Bug 修复、性能优化、服务器排查、WordPress 网站维护和小功能迭代。
如果你的项目遇到以下情况，可以先从一次小问题排查开始合作：
- ✅ PHP / Laravel / Yii2 老项目无人维护
- ✅ Go / Gin 后端接口需要排查或优化
- ✅ WordPress 网站访问慢、报错或插件冲突
- ✅ Nginx / MySQL / Redis / Linux 服务器异常
- ✅ CDN / Cloudflare / DNS / HTTPS 配置问题
- ✅ 需要长期远程技术支持或兼职维护
更多介绍请查看：关于我 & 合作
微信：13980074657
邮箱：shuijingwanwq@gmail.com
Telegram：@shuijingwan
GitHub：https://github.com/shuijingwan
发表回复