Unmarshal JSON with "valid" zero values

Question

I have some JSON that I am unmarshalling into various structs so that I can then process the data, seemingly this is turning into the hardest part of the project!!!

The format of this JSON is that if the field is missing then it is essentially nil. This is following on from Default struct values but thought it deserved it's own question on SO.

A zero therefore is a valid value and I need to be able to discern this in my Go code. Is there a way to get Go to unmarshal into this struct with pointers at all?

In the example playground you can see what I mean, it "appears" to work but when I come to print out one of the pointer values it always prints the pointer address and not the actual value.

package main

import "fmt"
import "log"
import "encoding/json"

const inputMissing = `
["AAAAAA", {"testCode" : "Sss"}, 123456]
`

const inputZero = `
["AAAAAA", {"testCode" : "Sss", "missingInt" : 0, "defaultInt" : 0,"missingString" : "", "defaultString" : ""}, 123456]
`

type RawMessage struct {
    AlwaysString  string
    ClientData    ClientData
    ReceptionTime int
}

type ClientData struct {
    TestCode   string
    MissingInt *int
    DefaultInt int

    MissingString *string
    DefaultString string
}

func main() {

    var n RawMessage
    if err := json.Unmarshal([]byte(inputMissing), &n); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%#v\n", n)

    var o RawMessage
    if err := json.Unmarshal([]byte(inputZero), &o); err != nil {
        log.Fatal(err)
    }

    fmt.Printf("%#v\n", o)

    fmt.Printf("Should print the value of the int, not pointer... %i", o.ClientData.MissingInt)
}

func (n *RawMessage) UnmarshalJSON(buf []byte) error {
    tmp := []interface{}{&n.AlwaysString, &n.ClientData, &n.ReceptionTime}
    wantLen := len(tmp)
    if err := json.Unmarshal(buf, &tmp); err != nil {
        return err
    }
    if g, e := len(tmp), wantLen; g != e {
        return fmt.Errorf("wrong number of fields in RawMessage: %d != %d", g, e)
    }
    return nil
}

I don't get it. If you need the value, why won't you just check the pointer against `nil` and then dereference it? — Ainar-G, Dec 05 '16 at 10:06
I am not sure the unmarshal is setting the value correctly. Whatever I do I cannot get the 0 (or any other value) able to be read from `MissingInt` or `MissingString` — Lee Armstrong, Dec 05 '16 at 10:07
Maybe a better example is https://play.golang.org/p/RWKCFtlhMk, I can't get to print out/read the 555 or test — Lee Armstrong, Dec 05 '16 at 10:08
Yes sorry, I feel really stupid now to not have checked that! — Lee Armstrong, Dec 05 '16 at 10:11

score 4 · Accepted Answer · answered Dec 05 '16 at 10:09

4

Your code is correct. Test the pointer against nil and dereference the pointer if you want the value:

fmt.Printf("Should print the value of the int, not pointer... %d", *o.ClientData.MissingInt)

answered Dec 05 '16 at 10:09

Franck Jeannin

6,107
3
21
33

Ah yes sorry, I was missing that! I feel like an idiot now! – Lee Armstrong Dec 05 '16 at 10:10
1

You should not. There is no such thing as a stupid question. – Franck Jeannin Dec 05 '16 at 10:12
Thanks! When using pointers there instead of values in the struct do I have to be careful with memory leaks at all or will GC still kick in for the whole struct when I am done with the object? – Lee Armstrong Dec 05 '16 at 10:17
1

GC will take care of that. – Franck Jeannin Dec 05 '16 at 10:19

icza · Answer 2 · 2016-12-05T11:03:27.027

Your confusion arises from the default formatting of the fmt package, which prints the hex value in case of pointer fields, and not the pointed value.

If you're using the %#v verb for printing, you may implement the fmt.GoStringer interface on your struct to override this "behavior":

func (c ClientData) GoString() string {
    mi := "<missing>"
    if c.MissingInt != nil {
        mi = strconv.Itoa(*c.MissingInt)
    }
    ms := "<missing>"
    if c.MissingString != nil {
        ms = *c.MissingString
    }

    return fmt.Sprintf("{TestCode: %s, MissingInt: %s, DefaultInt: %d, MissingString: %s, DefaultString: %s}",
        c.TestCode, mi, c.DefaultInt, ms, c.DefaultString)
}

And changing the last printing line to:

fmt.Printf("Should print the value of the int, not pointer... %d",
    *o.ClientData.MissingInt)

Your output becomes more readable (try it on the Go Playground):

main.RawMessage{AlwaysString:"AAAAAA", ClientData:{TestCode: Sss, MissingInt: <missing>, DefaultInt: 0, MissingString: <missing>, DefaultString: }, ReceptionTime:123456}
main.RawMessage{AlwaysString:"AAAAAA", ClientData:{TestCode: Sss, MissingInt: 0, DefaultInt: 0, MissingString: , DefaultString: }, ReceptionTime:123456}
Should print the value of the int, not pointer... 0

As you can see from the output above, the MissingXX fields have the static value <missing> displayed.

Note: If you were to use the %v verb, you'd have to implement the fmt.Stringer interface, which is basically the same, just the method name is not GoString() but simply String().

Thank you very much for taking the time to explain this. That was very useful. — Lee Armstrong, Dec 05 '16 at 10:35

Unmarshal JSON with "valid" zero values

2 Answers2