Go语言：如何将无结构YAML反序列化为GolangCasing键？

问题背景 #

使用gopkg.in/yaml.v3反序列化无结构YAML数据到map[interface{}]interface{}时，所有键会保留原YAML中的小写格式；而如果要得到符合Golang驼峰命名（GolangCasing）的键，常规做法是提前定义结构体并通过yaml标签映射，但实际场景中无法预先知晓YAML的结构。尝试过sigs.k8s.io/yaml库，但该库仍需预定义结构和转换规则，无法满足无结构场景的需求。

解决方案 #

目前没有现成工具可以直接实现无结构YAML到驼峰键的转换，需要通过以下两种方式手动实现：

1. 递归遍历转换Map键

核心思路是先完成常规反序列化，再递归遍历整个map结构，将每个键从原格式转换为驼峰格式，同时处理嵌套的map和slice。

首先实现键名转换函数（支持下划线分隔的键转大驼峰，单小写键转首字母大写）：

import "strings"

func toCamelCase(s string) string {
	parts := strings.Split(s, "_")
	for i := range parts {
		if parts[i] == "" {
			continue
		}
		parts[i] = strings.ToUpper(string(parts[i][0])) + parts[i][1:]
	}
	return strings.Join(parts, "")
}

再实现递归转换逻辑：

import "fmt"

func convertMapKeysToCamelCase(m map[interface{}]interface{}) map[string]interface{} {
	result := make(map[string]interface{})
	for k, v := range m {
		keyStr, ok := k.(string)
		if !ok {
			// 非字符串键直接保留原格式
			result[fmt.Sprintf("%v", k)] = v
			continue
		}
		camelKey := toCamelCase(keyStr)
		switch val := v.(type) {
		case map[interface{}]interface{}:
			result[camelKey] = convertMapKeysToCamelCase(val)
		case []interface{}:
			result[camelKey] = convertSliceElementsToCamelCase(val)
		default:
			result[camelKey] = val
		}
	}
	return result
}

func convertSliceElementsToCamelCase(slice []interface{}) []interface{} {
	result := make([]interface{}, len(slice))
	for i, v := range slice {
		switch val := v.(type) {
		case map[interface{}]interface{}:
			result[i] = convertMapKeysToCamelCase(val)
		case []interface{}:
			result[i] = convertSliceElementsToCamelCase(val)
		default:
			result[i] = val
		}
	}
	return result
}

使用示例：

func main() {
	m := make(map[interface{}]interface{})
	err := yaml.Unmarshal([]byte(data), &m)
	if err != nil {
		log.Fatalf("error: %v", err)
	}
	// 转换为驼峰键的map
	camelMap := convertMapKeysToCamelCase(m)
	fmt.Printf("--- camel case map:\n%v\n\n", camelMap)
}

2. 利用yaml.v3的自定义节点处理

通过yaml.Node直接遍历YAML节点树，在解码过程中修改键名，避免先反序列化为原始map再转换的步骤，性能更优。

示例代码：

func unmarshalToCamelCase(yamlData []byte) (interface{}, error) {
	var node yaml.Node
	if err := yaml.Unmarshal(yamlData, &node); err != nil {
		return nil, err
	}
	return processNode(&node)
}

func processNode(node *yaml.Node) (interface{}, error) {
	switch node.Kind {
	case yaml.MappingNode:
		result := make(map[string]interface{})
		for i := 0; i < len(node.Content); i += 2 {
			keyNode := node.Content[i]
			valNode := node.Content[i+1]
			key := toCamelCase(keyNode.Value)
			val, err := processNode(valNode)
			if err != nil {
				return nil, err
			}
			result[key] = val
		}
		return result, nil
	case yaml.SequenceNode:
		result := make([]interface{}, len(node.Content))
		for i, item := range node.Content {
			val, err := processNode(item)
			if err != nil {
				return nil, err
			}
			result[i] = val
		}
		return result, nil
	default:
		// 处理字符串、数字等基本类型
		var val interface{}
		if err := node.Decode(&val); err != nil {
			return nil, err
		}
		return val, nil
	}
}

使用示例：

func main() {
	camelData, err := unmarshalToCamelCase([]byte(data))
	if err != nil {
		log.Fatalf("error: %v", err)
	}
	fmt.Printf("--- camel case data:\n%v\n\n", camelData)
}

说明 #

• 上述toCamelCase函数可根据实际需求调整（比如支持短横线分隔的键转换）
• 第二种方法直接操作YAML节点，避免了二次遍历转换，适合处理大型YAML数据

内容的提问来源于stack exchange，提问作者xpt