用golang实现json序列化,避免输出null

最近开发过程遇到一个go序列化的问题,
前端要求数据返回

{
 "user":"zhangsan",
 "role":[
 {"name":"管理员"},{"name":"观察者"}
 ]
}

go中的数据结构是这样的

type Role struct{
 Name string `json:"name"`
}
type Info {
 User string `json:"user"`
 Role []Role `json:"role"`
}
data,_:=json.Marshal(&info{User:"zhangsan"})
fmt.Println(string(data))

如果info.Role没有数据时,因为go的json标准库会将空切片、空指针返回null,实际返回给前端的数据是这样的

{
 "user":"zhangsan",
 "role":null
}

这个数据前端拿到后判断role的长度时就会出错,一般的做法是初始化切片Role

type Role struct{
 Name string `json:"name"`
}
type Info {
 User string `json:"user"`
 Role []Role `json:"role"`
}
data:=json.Marshal(&info{User:"zhangsan",Role:[]Role{}})
fmt.Println(string(data))

这样就可以按照协定的结构返回数据

{
 "user":"zhangsan",
 "role":[]
}

但是我们存在大量这样的代码,如果要都初始化一次,那简直是丧心病狂????,就像下面这样

type Info {
 User string `json:"user"`
 Role []Role 
 Cols1 []string
 Cols2 []string
 Cols3 []string
 Cols4 []string
 Cols5 []string
 Cols6 []string
 ...//不知道还有n多
}

网上找了一大圈也没找到有处理这种情况的办法,还是自己动手写了个简单的处理器

package binding
import (
 "reflect"
 "strconv"
 "strings"
)
type marshal struct {
}
//json反序列化
func Marshal(obj interface{}) string {
 v := reflect.ValueOf(obj)
 return new(marshal).parse(v)
}
//处理开始
func (this *marshal) parse(v reflect.Value) string {
 if v.Kind() == reflect.Ptr {
 v = v.Elem()
 }
 switch v.Kind() {
 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 return strconv.FormatInt(v.Int(), 10)
 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 return strconv.FormatUint(v.Uint(), 10)
 case reflect.Float32, reflect.Float64:
 return strconv.FormatFloat(v.Float(), 'f', -1, 64)
 case reflect.String:
 return `"` + v.String() + `"`
 case reflect.Bool:
 return strconv.FormatBool(v.Bool())
 case reflect.Struct:
 return this.parseStruct(v, v.Type())
 case reflect.Map:
 return this.parseMap(v, v.Type())
 case reflect.Slice:
 return this.parseSlice(v, v.Type())
 case reflect.Interface:
 return this.parse(reflect.ValueOf(v.Interface()))
 }
 return "null"
}
//处理结构体
func (this *marshal) parseStruct(v reflect.Value, t reflect.Type) string {
 if v.Kind() == reflect.Ptr {
 v = v.Elem()
 }
 if t.Kind() == reflect.Ptr {
 t = t.Elem()
 }
 var str = make([]string, t.NumField())
 for i := 0; i < t.NumField(); i++ {
 field := t.Field(i)
 value := v.Field(i)
 fieldName := field.Name
 tag := field.Tag.Get("json")
 if tag != "" {
 f := strings.Split(tag, ",")
 fieldName = f[0]
 }
 if fieldName == "-" {
 continue
 }
 str[i]= `"`+fieldName+`":`+this.parse(value)
 }
 return "{" + strings.Join(str, ",") + "}"
}
//处理切片
func (this *marshal) parseSlice(v reflect.Value, t reflect.Type) string {
 var str = make([]string, v.Len())
 for i := 0; i < v.Len(); i++ {
 str [i]= this.parse(v.Index(i))
 }
 return `[` + strings.Join(str, ",") + "]"
}
//处理map
func (this *marshal) parseMap(v reflect.Value, t reflect.Type) string {
 var str = make([]string, v.Len())
 m := v.MapRange()
 var i int
 for m.Next() {
 str[i]= `"`+m.Key().String()+`":`+this.parse(m.Value())
 i++
 }
 return "{" + strings.Join(str, ",") + "}"
}

使用方法

type Role struct {
 Name string `json:"name"`
}
type Info struct {
 Name string `json:"name"`
 Role []Role `json:"role"`
}
s := Marshal(Info{Name: "zhangsan"})
fmt.Println(s)

输出结果

{"name":"zhangsan","role":[]}

好用是好用,但是性能比标准库差了5倍,一般情况下也足够了????

本文来自:简书

感谢作者:悟道人

查看原文:用golang实现json序列化,避免输出null

• 编辑
• 预览