在转换为JSON之前，如何处理浮点无穷大的问题？

huangapple
go评论124阅读模式
英文:

Go How to deal with float infinity before converting to JSON

问题

我遇到了一个情况，其中我有一些可能是无穷大/NaN的float64字段，尝试将其编组为JSON会导致错误，错误信息是不支持+Inf类型。

这个结构体最初是通过另一个库（Google Firestore）进行填充的。

实际上，这个结构体要大得多，有很多其他的浮点字段。

我认为我可以使用下面的循环来使用反射找到它们，不过我想知道是否有更简洁或更符合惯例的方法。

  1. v := reflect.ValueOf(structVar)
  2. typeOfS := v.Type()
  3. for i := 0; i < v.NumField(); i++ {
  4.   if typeOfS.Field(i).Type.Kind() == reflect.Float64 && math.IsInf(v.Field(i).Interface().(float64), 1) {
  5.     // ... 我将在这里放置一些逻辑
  6.   }
  7. }

我不太理解如何实现自定义编组，也许这可以是处理+Inf的一种选项？

英文:

I've come across a situation where I have some float64 fields that could be infinity/NaN and trying to marshal to JSON would result in an error regarding +Inf type isn't supported.

  1. type Something interface {
  2.   Id string `firestore:&quot;id&quot;`
  3.   NumberA float64 `firestore:&quot;numberA&quot;`
  4.   NumberB float64 `firestore:&quot;numberB&quot;`
  5.   NumberC float64 `firestore:&quot;numberC&quot;`
  6. }

This struct gets initially populated via another library (Google Firestore).

In reality this struct is much larger with a lot more fields that are floats.

I think I could use something like this loop below using reflect to to find them all, though I wonder if there is a cleaner way or more idiomatic approach.

  1. v := reflect.ValueOf(structVar)
  2. typeOfS := v.Type()
  3. for i := 0; i&lt; v.NumField(); i++ {
  4.   if typeOfS.Field(i).Type.Kind() == reflect.Float64 &amp;&amp; math.IsInf(v.Field(i).Interface().(float64), 1) {
  5.     // ... some logic I&#39;ll put here
  6.   }
  7. }

I don't understand how to implement custom marshalling so maybe that could be an option to handle +Inf?

答案1

得分: 2

自定义处理值可以通过实现Marshaler接口的自定义类型来完成。不过，你的Something类型是有问题的。它被定义为type Something interface{}，而实际上应该是type Something struct：

  1. type Something struct {
  2.     Id      string    `firestore:"id"`
  3.     NumberA JSONFloat `firestore:"numberA"`
  4.     NumberB JSONFloat `firestore:"numberB"`
  5.     NumberC JSONFloat `firestore:"numberC"`
  6. }
  8. type JSONFloat float64
  10. func (j JSONFloat) MarshalJSON() ([]byte, error) {
  11.     v := float64(j)
  12.     if math.IsInf(j, 0) {
  13.         // 处理无穷大，将期望的值赋给v
  14.         // 或者使用+/-表示无穷大
  15.         s := "+"
  16.         if math.IsInf(v, -1) {
  17.             s = "-"
  18.         }
  19.         return []byte(s), nil
  20.     }
  21.     return json.Marshal(v) // 将结果作为标准的float64进行编组
  22. }
  24. func (j *JSONFloat) UnmarshalJSON(v []byte) error {
  25.     if s := string(v); s == "+" || s == "-" {
  26.         // 如果+/-表示无穷大
  27.         if s == "+" {
  28.             *j = JSONFloat(math.Inf(1))
  29.             return nil
  30.         }
  31.         *j = JSONFloat(math.Inf(-1))
  32.         return nil
  33.     }
  34.     // 只是一个普通的浮点数值
  35.     var fv float64
  36.     if err := json.Unmarshal(v, &fv); err != nil {
  37.         return err
  38.     }
  39.     *j = JSONFloat(fv)
  40.     return nil
  41. }

这样应该可以了。

英文:

Custom handling of values can be done through custom types that implement the Marshaler interface. Your Something type, though, is malformed. It's defined as type Something interface{}, whereas that really ought the be a type Something struct:

  1. type Something struct {
  2.     Id      string    `firestore:&quot;id&quot;`
  3.     NumberA JSONFloat `firestore:&quot;numberA&quot;`
  4.     NumberB JSONFloat `firestore:&quot;numberB&quot;`
  5.     NumberC JSONFloat `firestore:&quot;numberC&quot;`
  6. }
  8. type JSONFloat float64
  10. func (j JSONFloat) MarshalJSON() ([]byte, error) {
  11.     v := float64(j)
  12.     if math.IsInf(j, 0) {
  13.         // handle infinity, assign desired value to v
  14.         // or say +/- indicates infinity
  15.         s := &quot;+&quot;
  16.         if math.IsInf(v, -1) {
  17.             s = &quot;-&quot;
  18.         }
  19.         return []byte(s), nil
  20.     }
  21.     return json.Marshal(v) // marshal result as standard float64
  22. }
  24. func (j *JSONFloat) UnsmarshalJSON(v []byte) error {
  25.     if s := string(v); s == &quot;+&quot; || s == &quot;-&quot; {
  26.         // if +/- indiciates infinity
  27.         if s == &quot;+&quot; {
  28.             *j = JSONFloat(math.Inf(1))
  29.             return nil
  30.         }
  31.         *j = JSONFloat(math.Inf(-1))
  32.         return nil
  33.     }
  34.     // just a regular float value
  35.     var fv float64
  36.     if err := json.Unmarshal(v, &amp;fv); err != nil {\
  37.         return err
  38.     }
  39.     *j = JSONFloat(fv)
  40.     return nil
  41. }

That should do it

答案2

得分: 0

我创建了xhhuango/json来支持NaN、+Inf和-Inf。

  1. type T struct {
  2.     N  float64
  3.     IP float64
  4.     IN float64
  5. }
  7. func TestMarshalNaNAndInf(t *testing.T) {
  8.     s := T{
  9.         N:  math.NaN(),
  10.         IP: math.Inf(1),
  11.         IN: math.Inf(-1),
  12.     }
  13.     got, err := Marshal(s)
  14.     if err != nil {
  15.         t.Errorf("Marshal() error: %v", err)
  16.     }
  17.     want := `{"N":NaN,"IP":+Inf,"IN":-Inf}`
  18.     if string(got) != want {
  19.         t.Errorf("Marshal() = %s, want %s", got, want)
  20.     }
  21. }
  23. func TestUnmarshalNaNAndInf(t *testing.T) {
  24.     data := []byte(`{"N":NaN,"IP":+Inf,"IN":-Inf}`)
  25.     var s T
  26.     err := Unmarshal(data, &s)
  27.     if err != nil {
  28.         t.Fatalf("Unmarshal: %v", err)
  29.     }
  30.     if !math.IsNaN(s.N) || !math.IsInf(s.IP, 1) || !math.IsInf(s.IN, -1)     {
  31.         t.Fatalf("after Unmarshal, s.N=%f, s.IP=%f, s.IN=%f, want NaN, +Inf, -Inf", s.N, s.IP, s.IN)
  32.     }
  33. }
英文:

I created xhhuango/json to support NaN, +Inf, and -Inf.

  1. type T struct {
  2.     N  float64
  3.     IP float64
  4.     IN float64
  5. }
  7. func TestMarshalNaNAndInf(t *testing.T) {
  8.     s := T{
  9.         N:  math.NaN(),
  10.         IP: math.Inf(1),
  11.         IN: math.Inf(-1),
  12.     }
  13.     got, err := Marshal(s)
  14.     if err != nil {
  15.         t.Errorf(&quot;Marshal() error: %v&quot;, err)
  16.     }
  17.     want := `{&quot;N&quot;:NaN,&quot;IP&quot;:+Inf,&quot;IN&quot;:-Inf}`
  18.     if string(got) != want {
  19.         t.Errorf(&quot;Marshal() = %s, want %s&quot;, got, want)
  20.     }
  21. }
  23. func TestUnmarshalNaNAndInf(t *testing.T) {
  24.     data := []byte(`{&quot;N&quot;:NaN,&quot;IP&quot;:+Inf,&quot;IN&quot;:-Inf}`)
  25.     var s T
  26.     err := Unmarshal(data, &amp;s)
  27.     if err != nil {
  28.         t.Fatalf(&quot;Unmarshal: %v&quot;, err)
  29.     }
  30.     if !math.IsNaN(s.N) || !math.IsInf(s.IP, 1) || !math.IsInf(s.IN, -1)     {
  31.         t.Fatalf(&quot;after Unmarshal, s.N=%f, s.IP=%f, s.IN=%f, want NaN, +Inf, -Inf&quot;, s.N, s.IP, s.IN)
  32.     }
  33. }

huangapple
  • 本文由 发表于 2022年10月24日 17:48:30
  • 转载请务必保留本文链接：https://go.coder-hub.com/74179310.html
  • go
  • json
  • marshalling
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定