Golang中如何创建动态嵌套的map[string]interface{}

更新了已裁剪请求体的示例

package main

import (
    "fmt"
    "io"
    "net/http"
    "strings"
)

func main() {
    // 示例：发送一个POST请求，请求体已被裁剪
    url := "https://httpbin.org/post"
    payload := strings.NewReader(`{"key1":"value1","key2":"value2"}`)

    req, err := http.NewRequest("POST", url, payload)
    if err != nil {
        fmt.Println("创建请求失败:", err)
        return
    }
    req.Header.Add("Content-Type", "application/json")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("发送请求失败:", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("读取响应体失败:", err)
        return
    }
    fmt.Println(string(body))
}

在Golang中创建动态嵌套的map[string]interface{}，可以使用递归或迭代的方式构建多层嵌套结构。对于MongoDB更新查询，特别是处理$set、$inc等操作符时，需要确保同一操作符下的不同字段不会被覆盖。

以下是基于你的需求实现的示例代码：

package main

import (
	"fmt"
)

func main() {
	// 创建根map
	update := make(map[string]interface{})
	
	// 动态构建嵌套结构
	buildNestedMap(update, "$set", "user.profile.name", "John")
	buildNestedMap(update, "$set", "user.profile.age", 30)
	buildNestedMap(update, "$inc", "stats.views", 1)
	buildNestedMap(update, "$inc", "stats.clicks", 1)
	buildNestedMap(update, "$push", "tags", "golang")
	buildNestedMap(update, "$push", "tags", "mongodb")
	
	fmt.Printf("%#v\n", update)
}

func buildNestedMap(root map[string]interface{}, operator, path string, value interface{}) {
	// 确保操作符层级存在
	if _, exists := root[operator]; !exists {
		root[operator] = make(map[string]interface{})
	}
	
	// 获取操作符map
	opMap := root[operator].(map[string]interface{})
	
	// 分割路径
	keys := splitPath(path)
	
	// 递归构建嵌套map
	buildMapRecursive(opMap, keys, value)
}

func splitPath(path string) []string {
	// 简单实现路径分割，实际可能需要更复杂的逻辑
	var keys []string
	start := 0
	for i := 0; i < len(path); i++ {
		if path[i] == '.' {
			keys = append(keys, path[start:i])
			start = i + 1
		}
	}
	if start < len(path) {
		keys = append(keys, path[start:])
	}
	return keys
}

func buildMapRecursive(current map[string]interface{}, keys []string, value interface{}) {
	if len(keys) == 1 {
		// 如果是数组操作符如$push，需要特殊处理
		if keys[0] == "" {
			// 处理数组索引情况
			return
		}
		
		// 检查是否已存在值（对于$push等操作需要追加）
		if existing, exists := current[keys[0]]; exists {
			// 如果是slice，则追加
			if slice, ok := existing.([]interface{}); ok {
				current[keys[0]] = append(slice, value)
				return
			}
		}
		current[keys[0]] = value
		return
	}
	
	// 确保下一级map存在
	key := keys[0]
	if _, exists := current[key]; !exists {
		current[key] = make(map[string]interface{})
	}
	
	// 递归处理下一级
	nextMap := current[key].(map[string]interface{})
	buildMapRecursive(nextMap, keys[1:], value)
}

对于更复杂的MongoDB更新操作，这里是一个更完整的实现，支持多种操作符和嵌套路径：

package main

import (
	"fmt"
	"strings"
)

type UpdateBuilder struct {
	update map[string]interface{}
}

func NewUpdateBuilder() *UpdateBuilder {
	return &UpdateBuilder{
		update: make(map[string]interface{}),
	}
}

func (b *UpdateBuilder) Set(path string, value interface{}) *UpdateBuilder {
	b.addOperation("$set", path, value)
	return b
}

func (b *UpdateBuilder) Inc(path string, value interface{}) *UpdateBuilder {
	b.addOperation("$inc", path, value)
	return b
}

func (b *UpdateBuilder) Push(path string, value interface{}) *UpdateBuilder {
	b.addOperation("$push", path, value)
	return b
}

func (b *UpdateBuilder) AddToSet(path string, value interface{}) *UpdateBuilder {
	b.addOperation("$addToSet", path, value)
	return b
}

func (b *UpdateBuilder) addOperation(operator, path string, value interface{}) {
	// 确保操作符map存在
	if _, exists := b.update[operator]; !exists {
		b.update[operator] = make(map[string]interface{})
	}
	
	opMap := b.update[operator].(map[string]interface{})
	keys := strings.Split(path, ".")
	
	// 构建嵌套结构
	current := opMap
	for i, key := range keys {
		if i == len(keys)-1 {
			// 最后一个键，设置值
			if operator == "$push" || operator == "$addToSet" {
				// 对于数组操作，确保值是数组
				if existing, exists := current[key]; exists {
					if slice, ok := existing.([]interface{}); ok {
						current[key] = append(slice, value)
					} else {
						current[key] = []interface{}{existing, value}
					}
				} else {
					current[key] = []interface{}{value}
				}
			} else {
				current[key] = value
			}
		} else {
			// 中间键，确保map存在
			if _, exists := current[key]; !exists {
				current[key] = make(map[string]interface{})
			}
			current = current[key].(map[string]interface{})
		}
	}
}

func (b *UpdateBuilder) Build() map[string]interface{} {
	return b.update
}

func main() {
	builder := NewUpdateBuilder()
	
	// 构建复杂的更新操作
	builder.
		Set("user.name", "John Doe").
		Set("user.age", 30).
		Set("user.address.city", "New York").
		Set("user.address.zip", "10001").
		Inc("stats.views", 1).
		Inc("stats.clicks", 5).
		Push("tags", "golang").
		Push("tags", "backend").
		AddToSet("skills", "programming").
		AddToSet("skills", "database")
	
	update := builder.Build()
	
	fmt.Println("Generated MongoDB update query:")
	for operator, value := range update {
		fmt.Printf("%s: %#v\n", operator, value)
	}
	
	// 输出结果可以直接用于MongoDB的UpdateOne/UpdateMany操作
	// collection.UpdateOne(ctx, filter, update)
}

这个实现提供了以下特性：

1. 支持多种MongoDB更新操作符（$set、$inc、$push、$addToSet等）
2. 自动创建嵌套的map结构
3. 对于数组操作符，自动处理值追加
4. 使用建造者模式提供流畅的API

输出结果示例：

map[string]interface{}{
    "$set": map[string]interface{}{
        "user": map[string]interface{}{
            "name": "John Doe",
            "age":  30,
            "address": map[string]interface{}{
                "city": "New York",
                "zip":  "10001",
            },
        },
    },
    "$inc": map[string]interface{}{
        "stats": map[string]interface{}{
            "views":  1,
            "clicks": 5,
        },
    },
    "$push": map[string]interface{}{
        "tags": []interface{}{"golang", "backend"},
    },
    "$addToSet": map[string]interface{}{
        "skills": []interface{}{"programming", "database"},
    },
}

这种方法确保了同一操作符下的不同字段不会被覆盖，并且可以动态构建任意深度的嵌套结构。