从Golang调试JSON错误

Question

我正在读取并解码其中有错误的大型JSON响应。现在我需要找到其中的错误是！我read about json.SyntaxError但我努力找出如何使用它。

package main 

import (
    "encoding/json" 
    "fmt" 
    "net/http" 
    "os" 
    "text/template" 
    "time" 
) 

type Movie struct { 
    Title  string `json:"title"` 
    PublishedAt time.Time `json:"published_at"` 
} 

func main() { 
    req, _ := http.NewRequest("GET", "https://s.natalian.org/2016-12-07/debugme2.json", nil) 
    resp, err := http.DefaultClient.Do(req) 

    defer resp.Body.Close() 
    dec := json.NewDecoder(resp.Body) 

    _, err = dec.Token() 
    for dec.More() { 
     var m Movie 
     if err = dec.Decode(&m); err != nil { 
      fmt.Println(err) 
      fmt.Println("Bad", m) 

      // https://blog.golang.org/error-handling-and-go 
      if serr, ok := err.(*json.SyntaxError); ok { 
       fmt.Println("Syntax error", serr) 
      } 

     } else { 
      fmt.Println("Good", m) 
     } 

     tmpl := template.Must(template.New("test").Parse("OUTPUT: {{ if .Title }}{{.Title}}{{ if .PublishedAt }} was published at {{.PublishedAt}} {{ end }}{{end}}\n")) 
     tmpl.Execute(os.Stdout, m) 
    } 

} 

我在想什么？任何工具或策略或建议将不胜感激。我的输出目前的样子：

Good {foobar 2016-11-24 16:17:12 +0800 SGT} 
OUTPUT: foobar was published at 2016-11-24 16:17:12 +0800 SGT 
parsing time ""null"" as ""2006-01-02T15:04:05Z07:00"": cannot parse "null"" as "2006" 
Bad {barbar 0001-01-01 00:00:00 +0000 UTC} 
OUTPUT: barbar was published at 0001-01-01 00:00:00 +0000 UTC 
Good { 1999-12-24 16:11:12 +0200 +0200} 
OUTPUT: 
Good {Something else entirely 2000-01-24 16:11:12 +0200 +0200} 
OUTPUT: Something else entirely was published at 2000-01-24 16:11:12 +0200 +0200 

但我需要这样的事情在我的错误输出到更好的调试问题：

Line 8: published_at is invalid 

等的标题也许有些情况下，所以我可以告诉API后端团队在他们的JSON响应中出现错误。

奖金问题：而且我不希望打印的价值0001-01-01 00:00:00 +0000 UTC因为它居然真的空。我并不介意它错过了。

Answer 1

一种方法既接受空值，如果published_at是空不打印任何东西，是PublishedAt字段设置为指针值：

type Movie struct { 
    Title  string `json:"title"` 
    PublishedAt *time.Time `json:"published_at"` 
} 

---

输入字符串是有效JSON ，所以json包不会引发SyntaxError。

的json封装具有一些其他错误类型，如UnmarshalTypeError时，当JSON不匹配nuilt入型中发生错误，其被升高（例如：string，int，array ...）。

不幸的是，当它调用自定义UnmarshalJSON()功能，它看起来像json包返回原始错误：

package main 

import (
    "bytes" 
    "encoding/json" 
    "fmt" 
    "time" 
) 

// check the full type of an error raised when Unmarshaling a json string 
func main() { 
    var test struct { 
     Clock time.Time 
    } 
    buf := bytes.NewBufferString(`{"Clock":null}`) 
    dec := json.NewDecoder(buf) 

    // ask to decode an invalid null value into a flat time.Time field : 
    err := dec.Decode(&test) 

    // print the details of the returned error : 
    fmt.Printf("%#v\n", err) 
} 

// Output : 
&time.ParseError{Layout:"\"2006-01-02T15:04:05Z07:00\"", Value:"null", LayoutElem:"\"", ValueElem:"null", Message:""} 

https://play.golang.org/p/fhZxVpOflb

最终的误差从time包中附带直，不json软件包中的某种UnmarshalError，它至少可以告诉您“尝试以此偏移量取值时出现此错误”，并且错误本身不会为您提供上下文。

---

你可以在错误特意找*time.ParseError类型：

if terr, ok := err.(*time.ParseError); ok { 
    // in the example : Movie has one single time.Time field ; 
    // if a time.ParseError occured, it was while trying to read that field 
    fmt.Println("Error when trying to read 'published_at' value", terr) 

    // you can leave the field to its zero value, 
    // or if you switched to a pointer field : 
    m.PublishedAt = nil 
} 

如果你碰巧有几个时间字段（如G：ProducedAt和PublishedAt），你仍然可以期待哪场留下了它的零值：

if terr, ok := err.(*time.ParseError); ok { 
    if m.ProducedAt.IsZero() { 
     fmt.Println("Error when trying to read 'produced_at' value", terr) 
    } 

    if m.PublishedAt == zero { 
     fmt.Println("Error when trying to read 'published_at' value", terr) 
    } 
} 

顺便说一句：在the docs规定，“0001-01-01 00:00:00 UTC”是去团队选择的零值为time.Time零值。

Answer 2

您的published_at数据为“null”，它是字符串类型，所以我认为您可以将PublishedAt定义为字符串，并且可以使用代码将其解析为time.Time。

这是我的测试代码：

package main 

import (
    "encoding/json" 

    "github.com/swanwish/go-common/logs" 
    "github.com/swanwish/go-common/utils" 
) 

func main() { 
    url := `https://s.natalian.org/2016-12-07/debugme2.json` 
    _, content, err := utils.GetUrlContent(url) 
    if err != nil { 
     logs.Errorf("Failed to get content from url %s, the error is %v", url, err) 
     return 
    } 

    movies := []struct { 
     Title  string `json:"title"` 
     PublishedAt string `json:"published_at"` 
    }{} 
    err = json.Unmarshal(content, &movies) 
    if err != nil { 
     logs.Errorf("Failed to unmarshal content %s, the error is %v", string(content), err) 
     return 
    } 
    logs.Debugf("The movies are %v", movies) 
} 

结果是：

The movies are [{foobar 2016-11-24T16:17:12.000+08:00} {barbar null} { 1999-12-24T16:11:12.000+02:00} {Something else entirely 2000-01-24T16:11:12.000+02:00}] 

Answer 3

它看起来像疯狂，但它应该工作：

rawBody := []byte(`{"title":"test", "published_at":"2017-08-05T15:04:05Z", "edited_at":"05.08.2017"}`) 

type Movie struct { 
    Title  string `json:"title"` 
    PublishedAt time.Time `json:"published_at"` 
    EditedAt time.Time `json:"edited_at"` 
} 

var msg Movie 

if err = json.Unmarshal(rawBody, &msg); err != nil { 
    if _, ok := err.(*time.ParseError); ok { 
     value := reflect.ValueOf(msg).Elem() 

     if value.Kind().String() != "struct" { 
      return err 
     } 

     for i := 0; i < value.NumField(); i++ { 
      field := value.Field(i) 

      if t, ok := field.Interface().(time.Time); ok { 
       if t.IsZero() { 
        name := value.Type().Field(i).Name 
        return fmt.Errorf("field: %s, message: %s", strings.ToLower(name), "time is not in RFC 3339 format.") 
       } 
      } 
     } 
    } 

    return err 
} 

此代码将先返回发生错误。如果PublishedAt无效，即使它是有效的，我们也不会对EditedA一无所知。