Golang 实现 Python 风格字典操作插件库

在 Go 语言中实现类似 Python 字典风格的便捷操作可以大大提高开发效率。下面我将介绍一个简单但功能强大的字典操作库实现。

基本实现

首先我们定义一个 Dict 类型，它本质上是对 map[string]interface{} 的封装：

package dict

import (
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
)

type Dict struct {
	data map[string]interface{}
}

// New 创建一个新的 Dict
func New() *Dict {
	return &Dict{
		data: make(map[string]interface{}),
	}
}

// FromMap 从现有 map 创建 Dict
func FromMap(m map[string]interface{}) *Dict {
	return &Dict{
		data: m,
	}
}

基本操作方法

增删改查

// Set 设置键值对
func (d *Dict) Set(key string, value interface{}) {
	d.data[key] = value
}

// Get 获取值
func (d *Dict) Get(key string) (interface{}, bool) {
	val, ok := d.data[key]
	return val, ok
}

// GetWithDefault 获取值，如果不存在则返回默认值
func (d *Dict) GetWithDefault(key string, defaultValue interface{}) interface{} {
	if val, ok := d.data[key]; ok {
		return val
	}
	return defaultValue
}

// Delete 删除键
func (d *Dict) Delete(key string) {
	delete(d.data, key)
}

// HasKey 检查键是否存在
func (d *Dict) HasKey(key string) bool {
	_, ok := d.data[key]
	return ok
}

字典合并

// Update 合并另一个字典
func (d *Dict) Update(other *Dict) {
	for k, v := range other.data {
		d.data[k] = v
	}
}

// Merge 合并多个字典
func (d *Dict) Merge(dicts ...*Dict) {
	for _, dict := range dicts {
		d.Update(dict)
	}
}

Python 风格方法实现

类似 Python 的 items(), keys(), values()

// Items 返回所有键值对，类似 Python 的 items()
func (d *Dict) Items() []struct {
	Key   string
	Value interface{}
} {
	var items []struct {
		Key   string
		Value interface{}
	}
	for k, v := range d.data {
		items = append(items, struct {
			Key   string
			Value interface{}
		}{k, v})
	}
	return items
}

// Keys 返回所有键，类似 Python 的 keys()
func (d *Dict) Keys() []string {
	keys := make([]string, 0, len(d.data))
	for k := range d.data {
		keys = append(keys, k)
	}
	return keys
}

// Values 返回所有值，类似 Python 的 values()
func (d *Dict) Values() []interface{} {
	values := make([]interface{}, 0, len(d.data))
	for _, v := range d.data {
		values = append(values, v)
	}
	return values
}

字典推导式风格方法

// Map 对字典中的每个键值对执行函数，返回新字典
func (d *Dict) Map(f func(key string, value interface{}) (string, interface{})) *Dict {
	newDict := New()
	for k, v := range d.data {
		newKey, newValue := f(k, v)
		newDict.Set(newKey, newValue)
	}
	return newDict
}

// Filter 过滤字典中的键值对
func (d *Dict) Filter(f func(key string, value interface{}) bool) *Dict {
	newDict := New()
	for k, v := range d.data {
		if f(k, v) {
			newDict.Set(k, v)
		}
	}
	return newDict
}

其他实用方法

JSON 序列化

// ToJSON 将字典转换为 JSON 字符串
func (d *Dict) ToJSON() (string, error) {
	jsonData, err := json.Marshal(d.data)
	if err != nil {
		return "", err
	}
	return string(jsonData), nil
}

// FromJSON 从 JSON 字符串创建字典
func FromJSON(jsonStr string) (*Dict, error) {
	var data map[string]interface{}
	err := json.Unmarshal([]byte(jsonStr), &data)
	if err != nil {
		return nil, err
	}
	return FromMap(data), nil
}

深度复制

// Copy 创建字典的浅拷贝
func (d *Dict) Copy() *Dict {
	newDict := New()
	for k, v := range d.data {
		newDict.Set(k, v)
	}
	return newDict
}

// DeepCopy 创建字典的深拷贝
func (d *Dict) DeepCopy() (*Dict, error) {
	jsonStr, err := d.ToJSON()
	if err != nil {
		return nil, err
	}
	return FromJSON(jsonStr)
}

使用示例

func main() {
	// 创建字典
	d := dict.New()
	d.Set("name", "Alice")
	d.Set("age", 30)
	d.Set("scores", []int{90, 85, 95})

	// 获取值
	if name, ok := d.Get("name"); ok {
		fmt.Println("Name:", name)
	}

	// 使用默认值
	address := d.GetWithDefault("address", "Unknown")
	fmt.Println("Address:", address)

	// 字典推导式
	upperDict := d.Map(func(key string, value interface{}) (string, interface{}) {
		return strings.ToUpper(key), value
	})
	fmt.Println("Upper keys dict:", upperDict.Keys())

	// 过滤
	filtered := d.Filter(func(key string, value interface{}) bool {
		return key != "age"
	})
	fmt.Println("Filtered keys:", filtered.Keys())

	// JSON 序列化
	jsonStr, _ := d.ToJSON()
	fmt.Println("JSON:", jsonStr)
}

扩展功能

如果需要更接近 Python 的使用体验，可以添加以下扩展：

1. 链式调用：修改方法返回 *Dict 自身
2. 运算符重载：通过方法模拟运算符行为
3. 默认值处理：更灵活的默认值机制
4. 嵌套字典访问：支持 dict.Get("a.b.c") 风格的嵌套访问

这个简单的 Dict 库已经提供了 Python 字典的核心功能，可以根据项目需求进一步扩展。它保持了 Go 语言的类型安全特性，同时提供了类似 Python 的便捷操作方式。