गो का उपयोग करके मैं JSON को कैसे प्रिंट कर सकता हूं?

Question

क्या किसी को गो में JSON आउटपुट को प्रिंट करने का एक सरल तरीका पता है?

स्टॉक http://golang.org/pkg/encoding/json/ पैकेज इस के लिए कार्यक्षमता को शामिल नहीं करता है (EDIT: यह करता है, स्वीकृत उत्तर देखें) और एक त्वरित Google कुछ भी स्पष्ट नहीं करता है।

मैं जिन चीज़ों की तलाश कर रहा हूँ, वे दोनों बहुत सुंदर हैं json.Marshal, जहाँ से JSON का पूरा स्ट्रिंग फॉर्मेट किया जा रहा है, जहाँ भी यह डिबग उद्देश्यों के लिए पढ़ना आसान है।

Comments

चेतावनी: मेरे प्रयोगों पर, JSON में स्ट्रिंग्स इंडेक्स को कोष्ठकों में संलग्न किया जाना चाहिए । तो, {name: "value"}ठीक नहीं होगा, इसके बावजूद कि अधिकांश जावास्क्रिप्ट दुभाषिया इसका उपयोग करते हैं । केवल {"name": "value"} गो JSON लाइब्रेरी फ़ंक्शंस के साथ काम करेगा।

— पीटर - मोनिका

@peterh मुझे लगता है कि आप JSON उचित के साथ जावास्क्रिप्ट शाब्दिक वाक्यविन्यास भ्रमित कर रहे हैं। JSON कल्पना ( json.org ) स्पष्ट रूप से इंगित करता है कि केवल स्ट्रिंग शाब्दिक अनुमति दी जाती है (जिसका अर्थ है कि इसे उद्धरण की आवश्यकता है), जबकि JS भाषा ऑब्जेक्ट सिंटैक्स में वह प्रतिबंध नहीं है। गो पुस्तकालय युक्ति का अनुसरण कर रहा है।

— ब्रैड पीबॉडी

Answer 1

सुंदर-प्रिंट से, मेरा मानना ​​है कि आप इंडेंटेड हैं, जैसे

{
    "data": 1234
}

बजाय

{"data":1234}

ऐसा करने का सबसे आसान तरीका है MarshalIndent, जो आपको यह निर्दिष्ट करने देगा कि आप इसे indentतर्क के माध्यम से कैसे पसंद करेंगे । इस प्रकार, json.MarshalIndent(data, "", " ")इंडेंटेशन के लिए चार स्थानों का उपयोग करके सुंदर प्रिंट होगा।

Comments

हाँ, यह केवल चीज़ की तरह दिखता है - यह पहले से ही अंतर्निहित है, केवल बाईं ओर pkg doc में कीवर्ड "सुंदर-प्रिंट" को शामिल करना है ताकि अगला लड़का खोज सके। (डॉक्टर रखरखाव के लिए एक प्रतिक्रिया नोट छोड़ देंगे।) Tks!

— ब्रैड पीबॉडी

json.MarshalIndent(data, "", "\t")अगर आपको टैब चाहिए

— काइल ब्रान्ड

json.MarshalIndent(data, "", "🐱")यदि आप बिल्लियों चाहते हैं। क्षमा करें

— briiC

json.MarshalIndent(data, "", "\t🐱")अगर आप चाहते हैं ... टैबी कैट ... सॉरी

— दावोस

Answer 2

स्वीकृत उत्तर बहुत अच्छा है यदि आपके पास कोई वस्तु है जिसे आप JSON में बदलना चाहते हैं। इस सवाल में भी किसी भी JSON स्ट्रिंग सुंदर मुद्रण का उल्लेख है, और यही मैं करने की कोशिश कर रहा था। मैं सिर्फ एक पोस्ट अनुरोध (विशेष रूप से एक सीएसपी उल्लंघन रिपोर्ट ) से कुछ JSON को बहुत लॉग-इन करना चाहता था ।

उपयोग करने के लिए 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()))
}

Answer 3

बेहतर स्मृति उपयोग के लिए, मुझे लगता है कि यह बेहतर है:

var out io.Writer
enc := json.NewEncoder(out)
enc.SetIndent("", "    ")
if err := enc.Encode(data); err != nil {
    panic(err)
}

Comments

था SetIndentप्राप्त हाल ही में जोड़ा? यह अनिवार्य रूप से अधिकांश के लिए अज्ञात है।

— चाप्पज

@chappjc SetIndent(मूल रूप से नामित Indent) को जाहिरा तौर पर मार्च 2016 में जोड़ा गया था और गो 1.7 में रिलीज़ किया गया था, जो इस सवाल के मूल रूप से पूछे जाने के लगभग 3 साल बाद था: github.com/golang/go/commit/… github.com/golang/go/commit/ ...

— एओयू

Answer 4

मैं गोसन में एक रंगीन स्ट्रिंग के लिए JSON को मार्शल करने के लिए एक तेज, उच्च गुणवत्ता वाले रास्ते की कमी से निराश था, इसलिए मैंने अपना खुद का मार्शलर लिखा, जिसका नाम 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))
}

मैं अब इसके लिए दस्तावेज लिख रहा हूं लेकिन मैं अपने समाधान को साझा करने के लिए उत्साहित था।

Answer 5

संपादित करें पीछे मुड़कर देखें, यह गैर-मुहावरेदार गो है। इस तरह के छोटे सहायक कार्य जटिलता का एक अतिरिक्त चरण जोड़ते हैं। सामान्य तौर पर, गो दर्शन 1 ट्रिकी लाइन पर 3 सरल रेखाओं को शामिल करना पसंद करता है।

---

जैसा कि @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/#/R4LWpkHIN या http://play.golang.org/p/R4LWpkHIN

Answer 6

यहाँ मैं क्या उपयोग है। यदि यह 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()
}

Answer 7

यहाँ मेरा समाधान है :

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
}

Answer 8

गो में शेल्फ सुंदर प्रिंटर से एक सरल। कोई इसे बाइनरी के माध्यम से संकलित कर सकता है:

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)
    }
}

यह बैश कमांड चलाने देता है जैसे:

cat myfile | jsonformat | grep "key"

Answer 9

package cube

import (
    "encoding/json"
    "fmt"
    "github.com/magiconair/properties/assert"
    "k8s.io/api/rbac/v1beta1"
    v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "testing"
)

func TestRole(t *testing.T)  {
    clusterRoleBind := &v1beta1.ClusterRoleBinding{
        ObjectMeta: v1.ObjectMeta{
            Name: "serviceaccounts-cluster-admin",
        },
        RoleRef: v1beta1.RoleRef{
            APIGroup: "rbac.authorization.k8s.io",
            Kind:     "ClusterRole",
            Name:     "cluster-admin",
        },
        Subjects: []v1beta1.Subject{{
            Kind:     "Group",
            APIGroup: "rbac.authorization.k8s.io",
            Name:     "system:serviceaccounts",
        },
        },
    }
    b, err := json.MarshalIndent(clusterRoleBind, "", "  ")
    assert.Equal(t, nil, err)
    fmt.Println(string(b))
}

Answer 10

मैं जाने के लिए नया हूँ, लेकिन यह वही है जो मैंने अभी तक इकट्ठा किया है:

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)

}

Answer 11

//You can do it with json.MarshalIndent(data, "", "  ")

package main

import(
  "fmt"
  "encoding/json" //Import package
)

//Create struct
type Users struct {
    ID   int
    NAME string
}

//Asign struct
var user []Users
func main() {
 //Append data to variable user
 user = append(user, Users{1, "Saturn Rings"})
 //Use json package the blank spaces are for the indent
 data, _ := json.MarshalIndent(user, "", "  ")
 //Print json formatted
 fmt.Println(string(data))
}