Go 语言函数设计原则：避免修改传入参数

核心原则

在 Go 语言中，函数应该遵循"不可变输入"的设计原则，即函数不应该修改调用者传入的参数。这是一个体现专业水平的重要编程实践。

详细解释

1. 函数的纯净性 (Purity)

什么是纯净函数？

相同输入总是产生相同输出
不产生副作用（不修改外部状态）
不依赖外部状态

示例对比：

go 复制代码

// 不纯净的函数 - 修改了输入参数
func ProcessMessage(msg *Message) {
    msg.Processed = true  // 修改了外部数据！
    msg.Timestamp = time.Now()
}

// 纯净的函数 - 不修改输入参数
func ProcessMessage(msg *Message) *Message {
    newMsg := *msg  // 创建副本
    newMsg.Processed = true
    newMsg.Timestamp = time.Now()
    return &newMsg
}

2. 副作用的危害

什么是副作用？

当函数执行时，除了返回值之外，还修改了程序的其他状态。

副作用带来的问题：

go 复制代码

// 危险的示例
func UpdateUser(user *User, name string) {
    user.Name = name           // 修改了外部对象
    user.LastModified = time.Now()  // 产生了副作用
}

// 调用代码
originalUser := &User{Name: "Alice", ID: 1}
UpdateUser(originalUser, "Bob")  // originalUser 被意外修改了！

fmt.Println(originalUser.Name)  // 输出: "Bob" - 原始数据被篡改！

3. 数据独立性的重要性

场景示例：

go 复制代码

type Config struct {
    Timeout  int
    Retry    int
    TaskID   string
}

// 共享配置对象
baseConfig := &Config{Timeout: 30, Retry: 3}

// 创建多个上下文，都使用同一个配置
ctx1, _ := NewContext(WithConfig(baseConfig))
ctx2, _ := NewContext(WithConfig(baseConfig))
ctx3, _ := NewContext(WithConfig(baseConfig))

// 如果直接修改 baseConfig：
// - ctx1 修改 TaskID 为 "task-1"
// - ctx2 修改 TaskID 为 "task-2" 
// - 所有 context 的 TaskID 都会变成 "task-2"！
// - baseConfig 也被修改了！

4. 可维护性和调试友好性

调试困难的场景：

go 复制代码

// 问题代码 - 难以调试
func CreateRequest(config *RequestConfig) *Request {
    config.RequestID = generateID()  // 修改了传入参数
    return &Request{Config: config}
}

// 调试时的困惑
config := &RequestConfig{Timeout: 30}
req1 := CreateRequest(config)
fmt.Println(config.RequestID)  // 什么？config 被修改了？

req2 := CreateRequest(config)  // 第二次调用时 config.RequestID 已有值

易于调试的版本：

go 复制代码

// 清晰的版本
func CreateRequest(config *RequestConfig) *Request {
    newConfig := *config  // 明确表示要创建新副本
    newConfig.RequestID = generateID()
    return &Request{Config: &newConfig}
}

// 调试时很清晰
config := &RequestConfig{Timeout: 30}
req1 := CreateRequest(config)
fmt.Println(config.RequestID)  // 仍然是空值，符合预期

🏗️ 专业实践标准

1. API 设计原则

go 复制代码

// ✅ 推荐：明确表示会创建新对象
func CloneWithID(original *Object, id string) *Object {
    cloned := *original
    cloned.ID = id
    return &cloned
}

// ❌ 不推荐：修改原对象
func SetID(original *Object, id string) {
    original.ID = id  // 修改了调用者的对象
}

2. 标准库的示范

Go 标准库中很多地方都遵循这个原则：

go 复制代码

// time 包的 Add 方法不修改原始时间
t := time.Now()
t2 := t.Add(time.Hour)  // 返回新时间，不修改 t

// strings 包的 ToUpper 不修改原始字符串
s := "hello"
s2 := strings.ToUpper(s)  // s 保持不变

3. 并发安全考虑

go 复制代码

// 在并发环境中的问题
var sharedConfig = &Config{Timeout: 30}

// Goroutine 1
go func() {
    ctx1 := CreateContext(sharedConfig)  // 如果修改了 sharedConfig...
}()

// Goroutine 2  
go func() {
    ctx2 := CreateContext(sharedConfig)  // ...这里会受到影响
}()

总结

避免修改传入参数是 Go 语言专业开发的核心实践，它体现了：

设计思维的成熟度 - 理解数据流向和生命周期
代码质量的保证 - 减少 bug 和不可预测行为
团队协作的友好性 - 其他开发者可以安全使用你的 API
系统稳定性的基础 - 避免意外的状态修改

这种设计原则在构建框架、库函数和大型系统时尤为重要，是区分初级和高级 Go 开发者的重要标志。