Golang 1.17循环中变量覆盖问题解析

是的，我需要先将更新后的映射复制到旧的映射中，因为可能还有其他字段也需要在所有语言中同步更新，但不包括文本内容。这就是我进行复制的原因。我该如何实现这个需求？

这种行为并非Go 1.17所特有。映射（map）和切片（slice）是“类引用”的值；它们本质上是指针，因此当你复制它们时，你复制的是指针：

source := map[string]int{"a": 1}

dest := source
dest["a"] = 2

fmt.Println(source["a"]) // 将打印 2

这是一个典型的Go语言中map引用共享导致的问题，不是Go 1.17的bug。问题出现在GetOtherLangSecDataToUpdate函数中对updatedSection.Settings的修改上。

问题分析

当你在循环中调用GetOtherLangSecDataToUpdate(section, postedSection)时，虽然postedSection是按值传递的，但其中的Settings字段是一个map[string]interface{}，而map在Go中是引用类型。

关键问题代码：

otherLangSec.Settings[fieldName] = updatedSection.Settings[fieldName]

这行代码实际上将updatedSection.Settings["title"]的引用赋值给了otherLangSec.Settings["title"]，导致两个map共享同一个底层数据。

示例重现

简化代码来展示问题：

package main

import "fmt"

type Section struct {
    Settings map[string]interface{}
}

func main() {
    posted := Section{
        Settings: map[string]interface{}{
            "title": map[string]interface{}{"content": "posted title"},
        },
    }
    
    other := Section{
        Settings: map[string]interface{}{
            "title": map[string]interface{}{"content": "other title"},
        },
    }
    
    // 修改other的title指向posted的title map
    other.Settings["title"] = posted.Settings["title"]
    
    // 现在修改other的title content
    titleMap := other.Settings["title"].(map[string]interface{})
    titleMap["content"] = "modified content"
    
    // 你会发现posted的title也被修改了！
    fmt.Println("posted title:", posted.Settings["title"]) // 输出: map[content:modified content]
}

解决方案

需要深度复制map，而不是共享引用：

func GetOtherLangSecDataToUpdate(otherLangSec, updatedSection Section) Section {
    for fieldName, oldSettIntrfc := range otherLangSec.Settings {
        if oldSettIntrfc != nil {
            // 深度复制map而不是共享引用
            switch updatedVal := updatedSection.Settings[fieldName].(type) {
            case map[string]interface{}:
                // 创建新的map并复制内容
                copiedMap := make(map[string]interface{})
                for k, v := range updatedVal {
                    copiedMap[k] = v
                }
                otherLangSec.Settings[fieldName] = copiedMap
            default:
                otherLangSec.Settings[fieldName] = updatedSection.Settings[fieldName]
            }
            
            switch oldSettIntrfc.(type) {
            case map[string]interface{}:
                // 处理嵌套逻辑
                oldSettings := oldSettIntrfc.(map[string]interface{})
                otherLangSecFieldObj := otherLangSec.Settings[fieldName].(map[string]interface{})
                
                switch fieldName {
                case "title":
                    if oldContent, exists := oldSettings["content"]; exists {
                        otherLangSecFieldObj["content"] = oldContent
                    }
                }
            default:
                continue
            }
        }
    }
    return otherLangSec
}

或者使用更通用的深度复制函数：

func deepCopyMap(original map[string]interface{}) map[string]interface{} {
    copied := make(map[string]interface{})
    for k, v := range original {
        switch val := v.(type) {
        case map[string]interface{}:
            copied[k] = deepCopyMap(val)
        default:
            copied[k] = v
        }
    }
    return copied
}

// 在函数中使用
otherLangSec.Settings[fieldName] = deepCopyMap(updatedSection.Settings[fieldName].(map[string]interface{}))

这个问题与Go版本无关，而是map引用语义的常见陷阱。在需要独立副本时，必须显式复制map的内容。