在Golang中解组json：必填字段？

如果在Golang中解组时在json中找不到字段，是否可能生成错误？我在文档中找不到它。是否有指定字段为必需的标记？

在

编码/json

包中没有将字段设置为“必需”的标记。您必须编写自己的

MarshalJSON（）

方法，或者对缺少的字段进行后期检查

要检查缺少的字段，必须使用指针来区分缺少的/null值和零值：

type JsonStruct struct {
    String *string
    Number *float64
}

完整工作示例：

package main

import (
    "fmt"
    "encoding/json"
)

type JsonStruct struct {
    String *string
    Number *float64
}

var rawJson = []byte(`{
    "string":"We do not provide a number"
}`)


func main() {
    var s *JsonStruct
    err := json.Unmarshal(rawJson, &s)
    if err != nil {
        panic(err)
    }

    if s.String == nil {
        panic("String is missing or null!")
    }

    if s.Number == nil {
        panic("Number is missing or null!")
    }

    fmt.Printf("String: %s  Number: %f\n", *s.String, *s.Number)
}

---

您还可以覆盖特定类型的解组（因此需要一个隐藏在几个json层中的字段），而无需将字段设置为指针。解组JSON由接口定义

type EnumItem struct {                                                                                            
    Named                                                                                                         
    Value string                                                                                                  
}                                                                                                                 

func (item *EnumItem) UnmarshalJSON(data []byte) (err error) {                                                    
    required := struct {                                                                                          
        Value *string `json:"value"`                                                                              
    }{}                                                                                                           
    all := struct {                                                                                               
        Named                                                                                                     
        Value string `json:"value"`                                                                               
    }{}                                                                                                           
    err = json.Unmarshal(data, &required)                                                                         
    if err != nil {                                                                                               
        return                                                                                                    
    } else if required.Value == nil {                                                                             
        err = fmt.Errorf("Required field for EnumItem missing")                                                   
    } else {                                                                                                      
        err = json.Unmarshal(data, &all)                                                                          
        item.Named = all.Named                                                                                    
        item.Value = all.Value                                                                                    
    }                                                                                                             
    return                                                                                                        
}                                                       

---

您只需实现该接口即可自定义JSON的解组方式。

这里是另一种方法，通过检查自定义的

标记

可以为结构创建标记，如：

type Profile struct {
    Name string `yourprojectname:"required"`
    Age  int
}

使用

reflect

检查标签是否分配了

必需的值

func (p *Profile) Unmarshal(data []byte) error {
    err := json.Unmarshal(data, p)
    if err != nil {
        return err
    }

    fields := reflect.ValueOf(p).Elem()
    for i := 0; i < fields.NumField(); i++ {

        yourpojectTags := fields.Type().Field(i).Tag.Get("yourprojectname")
        if strings.Contains(yourpojectTags, "required") && fields.Field(i).IsZero() {
            return errors.New("required field is missing")
        }

    }
    return nil
}

结果:

profile1 unmarshal: {foo 20}

2009/11/10 23:00:00 profile2 unmarshal error: required field is missing

您可以去查看已完成的代码
，也可以只检查默认值，这对于大多数情况可能已经足够了（除非您使用的是数字）。但是如果“必填字段”的值是默认值怎么办？如果数字的必填字段可能为0，并且您还需要检查是否提供了它，然后改为使用字符串来允许检查无输入，然后将字符串转换为后面的数字。如果所需字段是
struct
？@DeepakSah与structs相同，该怎么办。使用指向结构的指针。例如，
Object*Foo
，然后检查
s.Object==nil
。
profile1 unmarshal: {foo 20}

2009/11/10 23:00:00 profile2 unmarshal error: required field is missing