encoding/json: disable HTML escaping and omit final newline

[89z]

I am encoding some JSON. I need to disable HTML escaping, and I need no trailing
newline. It seems no easy way to do this.

If I try json#Marshal, it does HTML escaping with no option to change. If I
try json#Encoder.Encode, it adds newline with no option to change. I came up
with this as a workaround:

package main

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

func compact(dst *bytes.Buffer, v interface{}) error {
   var src bytes.Buffer
   enc := json.NewEncoder(&src)
   enc.SetEscapeHTML(false)
   err := enc.Encode(v)
   if err != nil {
      return err
   }
   return json.Compact(dst, src.Bytes())
}

func main() {
   var dst bytes.Buffer
   e := compact(&dst, []string{"May", "June & July"})
   if e != nil {
      log.Fatal(e)
   }
   fmt.Printf("%q", dst.String())
}

but its pretty awkward. Also if you wanted to indent, it is difficult, since you
are now calling json#Compact, using json#Encoder.SetIndent would be pointless, you
would have to call json#Indent after everything is done.

https://golang.org/pkg/encoding/json

[seankhliao]

This is possible with the current api (as you've demonstrated), see
https://golang.org/doc/faq#x_in_std

[89z]

@seankhliao my workaround is really inefficient. The Compact function is overkill to essentially remove a trailing newline, when it would be better if option to just not add the newline in the first place.

Also that link doesnt really relate to this issue. Im not asking to add a new package.

[seankhliao]

You can just slice off the last element of the byte slice.

[89z]

Here is another approach, based on your suggestion:

func marshal(v interface{}) ([]byte, error) {
   var dst bytes.Buffer
   enc := json.NewEncoder(&dst)
   enc.SetEscapeHTML(false)
   err := enc.Encode(v)
   if err != nil {
      return nil, err
   }
   return dst.Bytes()[:dst.Len() - 1], nil
}

Although since bytes is already being used, bytes#TrimSpace could be used instead. Here is a similar example using strings instead:

go/src/encoding/json/stream_test.go

Lines 150 to 156 in 00f2ff5

	var buf bytes.Buffer
	enc := NewEncoder(&buf)
	if err := enc.Encode(tt.v); err != nil {
	t.Errorf("Encode(%s): %s", tt.name, err)
	continue
	}
	if got := strings.TrimSpace(buf.String()); got != tt.wantEscape {

[mvdan]

Encoder enforcing a newline is unfortunate, but I agree with @seankhliao that it seems like a very minor inconvenience that doesn't warrant new API.

We are aware that Marshal and Encode are weird APIs, but they are not APIs we can break. And extending Encoder with more options isn't going to be particularly better in the long run :)

[mvdan]

cc @dsnet