Кто-нибудь знает простой способ красиво распечатать вывод JSON в Go?
Стандартный пакет http://golang.org/pkg/encoding/json/, похоже, не включает в себя функциональность для этого (ОБНОВЛЕНИЕ: да, см. принятый ответ), и быстрый Google не обнаруживает ничего очевидного.
Используемые мной способы - это как приятная печать результата json.Marshal, так и просто форматирование строки, полной JSON, откуда угодно, чтобы ее было легче читать в целях отладки.
Довольно принт, я предполагаю, что вы имеете в виду отступы, например,
{
"data": 1234
}
а не
{"data":1234}
Самый простой способ сделать это - MarshalIndent, который позволит вам указать, как вы хотите отступом с помощью аргумента indent. Таким образом, json.MarshalIndent(data, "", " ") будет довольно печатать, используя четыре пробела для отступа.
Принятый ответ велик, если у вас есть объект, который вы хотите превратить в JSON. В вопросе также упоминается довольно-печатная версия любой строки JSON и того, что я пытался сделать. Я просто хотел довольно-таки зарегистрировать JSON из запроса POST (в частности, отчет о нарушении CSP).
Чтобы использовать MarshalIndent, вы должны были бы Unmarshal вставить объект в объект. Если вам это нужно, пойдите для этого, но я этого не сделал. Если вам просто нужно довольно печатать массив байтов, обычный Indent является вашим другом.
Вот что я закончил с:
import (
"bytes"
"encoding/json"
"log"
"net/http"
)
func HandleCSPViolationRequest(w http.ResponseWriter, req *http.Request) {
body := App.MustReadBody(req, w)
if body == nil {
return
}
var prettyJSON bytes.Buffer
error := json.Indent(&prettyJSON, body, "", "\t")
if error != nil {
log.Println("JSON parse error: ", error)
App.BadRequest(w)
return
}
log.Println("CSP Violation:", string(prettyJSON.Bytes()))
}
Для лучшего использования памяти, я думаю, это лучше:
var out io.Writer
enc := json.NewEncoder(out)
enc.SetIndent("", " ")
if err := enc.Encode(data); err != nil {
panic(err)
}
Изменить Оглядываясь назад, это неидиоматический Go. Малому вспомогательному функциям, как это, добавляется дополнительный шаг сложности. В общем, философия Go предпочитает включать в себя 3 простые строки по 1 сложной линии.
Как отметил @robyoder, json.Indent - это путь. Думаю, я бы добавил эту небольшую функцию prettyprint:
package main
import (
"bytes"
"encoding/json"
"fmt"
)
//dont do this, see above edit
func prettyprint(b []byte) ([]byte, error) {
var out bytes.Buffer
err := json.Indent(&out, b, "", " ")
return out.Bytes(), err
}
func main() {
b := []byte(`{"hello": "123"}`)
b, _ = prettyprint(b)
fmt.Printf("%s", b)
}
https://go-sandbox.com/#/R4LWpkkHIN или http://play.golang.org/p/R4LWpkkHIN
Я был разочарован отсутствием быстрого и высококачественного способа маршалирования JSON в цветную строку в Go, поэтому я написал свой собственный маршаллер под названием ColorJSON.
С его помощью вы можете легко получить такой вывод, используя очень мало кода:
package main
import (
"fmt"
"encoding/json"
"github.com/TylerBrock/colorjson"
)
func main() {
str := '{
"str": "foo",
"num": 100,
"bool": false,
"null": null,
"array": ["foo", "bar", "baz"],
"obj": { "a": 1, "b": 2 }
}'
var obj map[string]interface{}
json.Unmarshal([]byte(str), &obj)
// Make a custom formatter with indent set
f := colorjson.NewFormatter()
f.Indent = 4
// Marshall the Colorized JSON
s, _ := f.Marshal(obj)
fmt.Println(string(s))
}
Я сейчас пишу документацию для него, но я был рад поделиться своим решением.
Вот что я использую. Если он не удается распечатать JSON, он просто возвращает исходную строку. Полезно для печати HTTP-ответов, которые должны содержать JSON.
import (
"encoding/json"
"bytes"
)
func jsonPrettyPrint(in string) string {
var out bytes.Buffer
err := json.Indent(&out, []byte(in), "", "\t")
if err != nil {
return in
}
return out.String()
}
import (
"bytes"
"encoding/json"
)
const (
empty = ""
tab = "\t"
)
func PrettyJson(data interface{}) (string, error) {
buffer := new(bytes.Buffer)
encoder := json.NewEncoder(buffer)
encoder.SetIndent(empty, tab)
err := encoder.Encode(data)
if err != nil {
return empty, err
}
return buffer.String(), nil
}
Простой в продаже симпатичный принтер в Go. Можно скомпилировать его в двоичный файл через:
go build -o jsonformat jsonformat.go
Он читает из стандартного ввода, пишет в стандартный вывод и позволяет установить отступ:
package main
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"io/ioutil"
"os"
)
func main() {
indent := flag.String("indent", " ", "indentation string/character for formatter")
flag.Parse()
src, err := ioutil.ReadAll(os.Stdin)
if err != nil {
fmt.Fprintf(os.Stderr, "problem reading: %s", err)
os.Exit(1)
}
dst := &bytes.Buffer{}
if err := json.Indent(dst, src, "", *indent); err != nil {
fmt.Fprintf(os.Stderr, "problem formatting: %s", err)
os.Exit(1)
}
if _, err = dst.WriteTo(os.Stdout); err != nil {
fmt.Fprintf(os.Stderr, "problem writing: %s", err)
os.Exit(1)
}
}
Это позволяет запускать команды bash, такие как:
cat myfile | jsonformat | grep "key"
Я новичок, но вот что я собрал:
package srf
import (
"bytes"
"encoding/json"
"os"
)
func WriteDataToFileAsJSON(data interface{}, filedir string) (int, error) {
//write data as buffer to json encoder
buffer := new(bytes.Buffer)
encoder := json.NewEncoder(buffer)
encoder.SetIndent("", "\t")
err := encoder.Encode(data)
if err != nil {
return 0, err
}
file, err := os.OpenFile(filedir, os.O_RDWR|os.O_CREATE, 0755)
if err != nil {
return 0, err
}
n, err := file.Write(buffer.Bytes())
if err != nil {
return 0, err
}
return n, nil
}
Это выполнение функции, и просто стандартное
b, _ := json.MarshalIndent(SomeType, "", "\t")
Код:
package main
import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
minerals "./minerals"
srf "./srf"
)
func main() {
//array of Test struct
var SomeType [10]minerals.Test
//Create 10 units of some random data to write
for a := 0; a < 10; a++ {
SomeType[a] = minerals.Test{
Name: "Rand",
Id: 123,
A: "desc",
Num: 999,
Link: "somelink",
People: []string{"John Doe", "Aby Daby"},
}
}
//writes aditional data to existing file, or creates a new file
n, err := srf.WriteDataToFileAsJSON(SomeType, "test2.json")
if err != nil {
log.Fatal(err)
}
fmt.Println("srf printed ", n, " bytes to ", "test2.json")
//overrides previous file
b, _ := json.MarshalIndent(SomeType, "", "\t")
ioutil.WriteFile("test.json", b, 0644)
}