proposal: encoding/json: skipping nil values when Unmarshal bytes

[mikolajsemeniuk]

Currently if w have struct like this:

type Product struct {
	Variants    []Variant `json:"variants"`
}

func (p *Product) Transform(input []byte) error {
	return json.Unmarshal(input, p)
}

There is no way to skip nil values so unmarshalling this json:

{
    "variants": [
         null,
        {
            "one": "two"
        },
        null,
    ]
}

Will produce:

product := Product{
	Variants: [] Variant{ 
                 {
 			One: "",
		},
	        {
 			One: "two",
		},
		{
 			One: "",
		},
	}
}

Would be nice if Unmarshal can skip nil values using something like this:

type Product struct {
	Variants    []Variant `json:"variants,skipempty"`
}

func (p *Product) Transform(input []byte) error {
	return json.Unmarshal(input, p)
}

What would product:

product := Product{
	Variants: []Variant{ 
	        {
 			One: "two",
		},
	}
}

[ianlancetaylor]

Dup of #22480?

[beoran]

@mikolajsemeniuk is the omitempty tag not what you need?

[seankhliao]

This looks different, but niche:
the tag is on the slice, and it wants to skip elements inside the slice if they are null.
Both the omitempty tag and the omitnil proposal only apply if the entire slice is nil/null.

[dsnet]

I believe anything about omitempty is a red-herring. The OP is asking about a change to Unmarshal behavior, while omitempty and related issues are about Marshal behavior.

@mikolajsemeniuk, what is the representation of the Variant type? In order for the behavior you're asking for to make sense, there must be a representation for Variant that naturally corresponds with a JSON null.

[mikolajsemeniuk]

@dsnet this is representation of Variant:

type Variant struct {
    Name string `json:"name"`
}