如何在结构体字段无omitempty标签时实现JSON Marshal忽略空字段

以下是几种可行的实现方式，你可以根据场景选择：

1. 反射动态构建带omitempty标签的临时结构体 #

通过反射遍历原结构体的所有字段，动态创建一个每个字段都带有json:"字段名,omitempty"标签的临时结构体，将原结构体的值拷贝到临时结构体后再进行序列化。这种方式无需修改原类型，且能通用处理任意结构体。

示例代码：

package main

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

type A struct {
	Name string
	Age  int
	Addr *string
}

func marshalIgnoreEmpty(v interface{}) ([]byte, error) {
	origType := reflect.TypeOf(v)
	if origType.Kind() != reflect.Struct {
		return json.Marshal(v)
	}
	origValue := reflect.ValueOf(v)

	// 构建临时结构体字段
	var tempFields []reflect.StructField
	for i := 0; i < origType.NumField(); i++ {
		field := origType.Field(i)
		tempField := field
		// 提取原json标签的字段名（如果有），否则用结构体字段名
		jsonFieldName := field.Name
		if origTag := field.Tag.Get("json"); origTag != "" {
			jsonFieldName = origTag
			// 处理原标签带其他选项的情况，比如`json:"name,omitempty"`，这里只取字段名部分
			if idx := indexOf(origTag, ","); idx != -1 {
				jsonFieldName = origTag[:idx]
			}
		}
		tempField.Tag = reflect.StructTag(fmt.Sprintf(`json:"%s,omitempty"`, jsonFieldName))
		tempFields = append(tempFields, tempField)
	}

	// 创建临时结构体并赋值
	tempType := reflect.StructOf(tempFields)
	tempValue := reflect.New(tempType).Elem()
	for i := 0; i < origType.NumField(); i++ {
		tempValue.Field(i).Set(origValue.Field(i))
	}

	return json.Marshal(tempValue.Interface())
}

// 辅助函数：查找字符串中字符的位置
func indexOf(s string, c byte) int {
	for i := range s {
		if s[i] == c {
			return i
		}
	}
	return -1
}

func main() {
	a := A{Name: "Alice", Age: 0, Addr: nil}
	data, err := marshalIgnoreEmpty(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data)) // 输出 {"Name":"Alice"}
}

2. 自定义MarshalJSON方法（适合字段较少的场景） #

如果生成的类型A允许你添加方法（比如同包下），可以为其实现自定义的MarshalJSON方法，手动过滤空值字段后转成map序列化。这种方式性能最优，但需要手动维护字段判断。

示例代码：

package main

import (
	"encoding/json"
	"fmt"
)

type A struct {
	Name string
	Age  int
	Addr *string
}

func (a A) MarshalJSON() ([]byte, error) {
	fieldMap := make(map[string]interface{})
	if a.Name != "" {
		fieldMap["Name"] = a.Name
	}
	if a.Age != 0 {
		fieldMap["Age"] = a.Age
	}
	if a.Addr != nil {
		fieldMap["Addr"] = a.Addr
	}
	return json.Marshal(fieldMap)
}

func main() {
	a := A{Name: "Bob", Addr: nil}
	data, err := json.Marshal(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data)) // 输出 {"Name":"Bob"}
}

3. 先转Map再过滤空值（简单场景快速实现） #

先将结构体序列化成map[string]interface{}，遍历Map删除空值后再重新序列化。这种方式实现简单，但存在两次序列化/反序列化的开销，嵌套结构体需要额外处理递归。

示例代码：

package main

import (
	"encoding/json"
	"fmt"
)

type A struct {
	Name string
	Age  int
	Addr *string
}

func marshalFilterEmpty(v interface{}) ([]byte, error) {
	// 先序列化结构体到Map
	var rawMap map[string]interface{}
	rawData, err := json.Marshal(v)
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(rawData, &rawMap); err != nil {
		return nil, err
	}

	// 过滤空值字段
	for key, val := range rawMap {
		switch value := val.(type) {
		case string:
			if value == "" {
				delete(rawMap, key)
			}
		case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64:
			if value == 0 {
				delete(rawMap, key)
			}
		case float32, float64:
			if value == 0 {
				delete(rawMap, key)
			}
		case bool:
			if !value {
				delete(rawMap, key)
			}
		case nil:
			delete(rawMap, key)
			// 嵌套结构体需要递归处理，这里可以添加对应的判断逻辑
		}
	}

	// 重新序列化处理后的Map
	return json.Marshal(rawMap)
}

func main() {
	a := A{Age: 25, Addr: nil}
	data, err := marshalFilterEmpty(a)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data)) // 输出 {"Age":25}
}

最佳方式选择 #

• 若需要通用处理任意结构体，且能接受反射的性能开销，优先选择反射构建临时结构体的方式；
• 若结构体字段较少，追求最优性能，选择自定义MarshalJSON方法；
• 简单测试场景下，快速实现可以用Map中转过滤的方式。

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