Specify struct format in json.Marshal()

I have the following structs, which I use to communicate with an API:

type Object struct {
	Id         uint64
	Type       string
	Class      string
	Properties []Property
}

type Property struct {
	Name     string
	DataType string
	Value    interface{}
}

And I use json.MarshalIndent() to convert my struct into a json before sending it. this gives me something like:

{
       "Id": 15,
       "Type": "Node",
       "Class": "Persona",
       "Properties": [
               {
                       "Name": "Nombre",
                       "DataType": "text",
                       "Value": "Oso"
               },
               {
                       "Name": "Edad",
                       "DataType": "int",
                       "Value": 45
               },
               {
                       "Name": "Fecha de Naciemiento",
                       "DataType": "date",
                       "Value": "1989-09-27T05:30:08-06:00"
               }
       ]
}

I want to format the value value (because it is of type interface{} I need to format it depending on the value type) of the struct Property before marshaling it.

The first solution that occurred to me was to create a (Object) encode() string function or something, that iterates through []Property formatting the values, and marshaling each property separately, then reconstructing the Object with an []string instead of the []Property and then marshaling the object.

Is there any built-in way of doing this? If not, is there any idiomatic way of doing it?

The JSON encoder marshals interface{} values according to the actual type of the value. You can override the default encoding in a couple of ways.

The first is to create a wrapper around values to control how they are encoded using the Marshaler interface. Here's a wrapper that changes how integers are encoded:

type Value struct{ Value interface{} }

func (v Value) MarshalJSON() ([]byte, error) {
  switch v := v.Value.(type) {
  case int:
	return []byte(fmt.Sprintf("\"#%d\"", v)), nil
  default:
	return json.Marshal(v)
  }
}

Use it like this:

prop.Value = Value{45}

<kbd>playground</kbd>

A second approach is to implement the Marshaler on the Property type to override how all of the property is marshaled including the Value field.

func (p Property) MarshalJSON() ([]byte, error) {
  var buf bytes.Buffer
  buf.WriteString(`{"Name":`)
  d, err := json.Marshal(p.Name)
  if err != nil {
	return nil, err
  }
  buf.Write(d)
  buf.WriteString(`,"DataType":`)
  d, err = json.Marshal(p.DataType)
  if err != nil {
	return nil, err
  }
  buf.Write(d)
  buf.WriteString(`, "Value":`)
  switch v := p.Value.(type) {
  case int:
	fmt.Fprintf(&buf, "\"#%d\"", v)
  default:
	d, err := json.Marshal(v)
	if err != nil {
		return nil, err
	}
	buf.Write(d)
  }
  buf.WriteString("}")
  return buf.Bytes(), nil
}

<kbd>playground</kbd>