कंसोल में स्ट्रक्चर चर कैसे प्रिंट करें?
जवाबों:
किसी संरचना में फ़ील्ड का नाम प्रिंट करने के लिए:
fmt.Printf("%+v\n", yourProject)से fmtपैकेज :
जब मुद्रण संरचना, प्लस ध्वज (
%+v) फ़ील्ड नाम जोड़ता है
मान लीजिए कि आपके पास परियोजना का एक उदाहरण है (' yourProject') में
JSON और गो का लेख एक JSON संरचना से मूल्यों को पुनः प्राप्त करने के तरीके के बारे में अधिक जानकारी देगा।
उदाहरण के लिए यह पृष्ठ एक और तकनीक प्रदान करता है:
type Response2 struct {
Page int `json:"page"`
Fruits []string `json:"fruits"`
}
res2D := &Response2{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res2B, _ := json.Marshal(res2D)
fmt.Println(string(res2B))
यह प्रिंट होगा:
{"page":1,"fruits":["apple","peach","pear"]}यदि आपके पास कोई उदाहरण नहीं है, तो आपको किसी दिए गए संरचना के क्षेत्र का नाम प्रदर्शित करने के लिए प्रतिबिंब का उपयोग करने की आवश्यकता है , जैसा कि इस उदाहरण में है ।
type T struct {
A int
B string
}
t := T{23, "skidoo"}
s := reflect.ValueOf(&t).Elem()
typeOfT := s.Type()
for i := 0; i < s.NumField(); i++ {
f := s.Field(i)
fmt.Printf("%d: %s %s = %v\n", i,
typeOfT.Field(i).Name, f.Type(), f.Interface())
}
मैं गो-स्पू की सिफारिश करना चाहता हूं , जो उनके गितुब के अनुसार "डिबगिंग में सहायता के लिए गो डेटा संरचनाओं के लिए एक गहरा सुंदर प्रिंटर लागू करता है"
go get -u github.com/davecgh/go-spew/spewउपयोग उदाहरण:
package main
import (
"github.com/davecgh/go-spew/spew"
)
type Project struct {
Id int64 `json:"project_id"`
Title string `json:"title"`
Name string `json:"name"`
Data string `json:"data"`
Commits string `json:"commits"`
}
func main() {
o := Project{Name: "hello", Title: "world"}
spew.Dump(o)
}उत्पादन:
(main.Project) {
Id: (int64) 0,
Title: (string) (len=5) "world",
Name: (string) (len=5) "hello",
Data: (string) "",
Commits: (string) ""
}मेरे 2cents का उपयोग करने के लिए होगा json.MarshalIndent- आश्चर्य की बात यह सुझाव नहीं है, क्योंकि यह सबसे सीधा है। उदाहरण के लिए:
func prettyPrint(i interface{}) string {
s, _ := json.MarshalIndent(i, "", "\t")
return string(s)
}कोई बाहरी deps और अच्छी तरह से स्वरूपित उत्पादन में परिणाम।
"\t"के साथ " "अगर आप अंतरिक्ष खिसकने के बजाय चाहते हैं
मुझे लगता है कि कस्टम स्ट्रिंगर को लागू करना बेहतर होगा यदि आप किसी प्रकार का स्वरूपित आउटपुट चाहते हैं struct
उदाहरण के लिए
package main
import "fmt"
type Project struct {
Id int64 `json:"project_id"`
Title string `json:"title"`
Name string `json:"name"`
}
func (p Project) String() string {
return fmt.Sprintf("{Id:%d, Title:%s, Name:%s}", p.Id, p.Title, p.Name)
}
func main() {
o := Project{Id: 4, Name: "hello", Title: "world"}
fmt.Printf("%+v\n", o)
}p = Project{...}
fmt.Printf("%+v", p)
fmt.Printf("%#v", p) //with typefmt.Printf(%#v, p), मुझे फेंकता main.structके साथ struct type क्या बीच का अंतर है "%#v"और "%+v"@cokebol
वैकल्पिक रूप से, इस फ़ंक्शन का उपयोग करके देखें PrettyPrint()
// print the contents of the obj
func PrettyPrint(data interface{}) {
var p []byte
// var err := error
p, err := json.MarshalIndent(data, "", "\t")
if err != nil {
fmt.Println(err)
return
}
fmt.Printf("%s \n", p)
}इसका उपयोग करने के लिए आपको किसी अतिरिक्त पैकेज की आवश्यकता नहीं है , fmtऔर encoding/jsonआपके द्वारा बनाई गई संरचना का केवल एक संदर्भ, सूचक, या शाब्दिक।
बस अपनी संरचना का उपयोग करने के लिए, इसे मुख्य या जो भी पैकेज में हों, उसे आरंभ करें और उसमें पास करें PrettyPrint()।
type Prefix struct {
Network string
Mask int
}
func valueStruct() {
// struct as a value
var nw Prefix
nw.Network = "10.1.1.0"
nw.Mask = 24
fmt.Println("### struct as a pointer ###")
PrettyPrint(&nw)
}यह आउटपुट होगा
### struct as a pointer ###
{
"Network": "10.1.1.0",
"Mask": 24
} यहां कोड के साथ खेलें ।
उनके रीडमे से:
type Person struct {
Name string
Age int
Parent *Person
}
litter.Dump(Person{
Name: "Bob",
Age: 20,
Parent: &Person{
Name: "Jane",
Age: 50,
},
})Sdump परीक्षण में बहुत आसान है:
func TestSearch(t *testing.T) {
result := DoSearch()
actual := litterOpts.Sdump(result)
expected, err := ioutil.ReadFile("testdata.txt")
if err != nil {
// First run, write test data since it doesn't exist
if !os.IsNotExist(err) {
t.Error(err)
}
ioutil.Write("testdata.txt", actual, 0644)
actual = expected
}
if expected != actual {
t.Errorf("Expected %s, got %s", expected, actual)
}
}मैं सुंदर प्रिंटर लाइब्रेरी का उपयोग करने की सलाह देता हूं । इसमें आप किसी भी स्ट्रक्चर को बहुत आसानी से प्रिंट कर सकते हैं।
लाइब्रेरी स्थापित करें
या
go get github.com/kr/prettyअब अपने कोड में ऐसा करें
package main
import (
fmt
github.com/kr/pretty
)
func main(){
type Project struct {
Id int64 `json:"project_id"`
Title string `json:"title"`
Name string `json:"name"`
Data Data `json:"data"`
Commits Commits `json:"commits"`
}
fmt.Printf("%# v", pretty.Formatter(Project)) //It will print all struct details
fmt.Printf("%# v", pretty.Formatter(Project.Id)) //It will print component one by one.
}इसके अलावा आप इस पुस्तकालय के माध्यम से घटक के बीच अंतर कर सकते हैं और बहुत कुछ। आप लाइब्रेरी डॉक्स पर भी नज़र डाल सकते हैं।
pretty.Formatter
जब आपके पास अधिक जटिल संरचनाएं होती हैं, तो आपको मुद्रण से पहले JSON में बदलने की आवश्यकता हो सकती है:
// Convert structs to JSON.
data, err := json.Marshal(myComplexStruct)
fmt.Printf("%s\n", data)पूरा कोड देखने के लिए यहां जाएं । यहां आपको एक ऑनलाइन टर्मिनल के लिए एक लिंक भी मिलेगा, जहां पूरा कोड चलाया जा सकता है और कार्यक्रम यह दर्शाता है कि संरचना की जानकारी कैसे निकालें (क्षेत्र का नाम उनके प्रकार और मूल्य)। नीचे कार्यक्रम स्निपेट है जो केवल फ़ील्ड नामों को प्रिंट करता है।
package main
import "fmt"
import "reflect"
func main() {
type Book struct {
Id int
Name string
Title string
}
book := Book{1, "Let us C", "Enjoy programming with practice"}
e := reflect.ValueOf(&book).Elem()
for i := 0; i < e.NumField(); i++ {
fieldName := e.Type().Field(i).Name
fmt.Printf("%v\n", fieldName)
}
}
/*
Id
Name
Title
*/गो-रेंडर भी है , जो स्ट्रिंग और इंट मैप के लिए पॉइंटर रिकर्सन और ढेर सारी की-सॉर्टिंग को हैंडल करता है।
स्थापना:
go get github.com/luci/go-render/renderउदाहरण:
type customType int
type testStruct struct {
S string
V *map[string]int
I interface{}
}
a := testStruct{
S: "hello",
V: &map[string]int{"foo": 0, "bar": 1},
I: customType(42),
}
fmt.Println("Render test:")
fmt.Printf("fmt.Printf: %#v\n", a)))
fmt.Printf("render.Render: %s\n", Render(a))कौन सा प्रिंट:
fmt.Printf: render.testStruct{S:"hello", V:(*map[string]int)(0x600dd065), I:42}
render.Render: render.testStruct{S:"hello", V:(*map[string]int){"bar":1, "foo":0}, I:render.customType(42)}fmt.Printf("%+v\n", project)यह विवरण छापने का मूल तरीका है
एक और तरीका है, एक फंक बनाएं जिसे कहा जाता है toStringकि संरचना करें, अपनी इच्छानुसार खेतों को प्रारूपित करें।
import (
"fmt"
)
type T struct {
x, y string
}
func (r T) toString() string {
return "Formate as u need :" + r.x + r.y
}
func main() {
r1 := T{"csa", "ac"}
fmt.Println("toStringed : ", r1.toString())
}Stringerइंटरफ़ेस को लागू कर सकते हैं । यह कुछ इस तरह दिखेगा: func (t T) String() string { return fmt.Sprintf("SomeT{TID: %d, TField: %d, SomeTField: %s, SomeAnotherField: %s}", t.ID, t.Field, t.SomeTField, t.SomeAnotherField) }
बाहरी पुस्तकालयों का उपयोग किए बिना और प्रत्येक क्षेत्र के बाद नई लाइन के साथ:
log.Println(
strings.Replace(
fmt.Sprintf("%#v", post), ", ", "\n", -1)) type Response struct {
UserId int `json:"userId"`
Id int `json:"id"`
Title string `json:"title"`
Body string `json:"body"`
}
func PostsGet() gin.HandlerFunc {
return func(c *gin.Context) {
xs, err := http.Get("https://jsonplaceholder.typicode.com/posts")
if err != nil {
log.Println("The HTTP request failed with error: ", err)
}
data, _ := ioutil.ReadAll(xs`enter code here`.Body)
// this will print the struct in console
fmt.Println(string(data))
// this is to send as response for the API
bytes := []byte(string(data))
var res []Response
json.Unmarshal(bytes, &res)
c.JSON(http.StatusOK, res)
}
}बहुत सरल मेरे पास डेटा और कमिट की संरचना नहीं है इसलिए मैंने इसे बदल दिया
package main
import (
"fmt"
)
type Project struct {
Id int64 `json:"project_id"`
Title string `json:"title"`
Name string `json:"name"`
Data string `json:"data"`
Commits string `json:"commits"`
}
func main() {
p := Project{
1,
"First",
"Ankit",
"your data",
"Commit message",
}
fmt.Println(p)
}सीखने के लिए आप यहां से मदद ले सकते हैं: https://gobyexample.com/structs
शायद इसे उत्पादन अनुरोधों के लिए लागू नहीं किया जाना चाहिए, लेकिन यदि आप डिबगिंग मोड पर हैं, तो मेरा सुझाव है कि आप नीचे दिए गए दृष्टिकोण का पालन करें।
marshalledText, _ := json.MarshalIndent(inputStruct, "", " ")
fmt.Println(string(marshalledText))इसके परिणामस्वरूप वृद्धि की पठनीयता के साथ डेटा को json प्रारूप में स्वरूपित किया जाता है।
इनमें से अधिकांश पैकेज ऐसी चीजों को संभव बनाने के लिए रिफ्लेक्ट पैकेज पर निर्भर हैं।
fmt.Sprintf () का उपयोग कर रहा है -> फंक (पी * पीपी) प्रिंटअर्ग (arg इंटरफ़ेस {}, क्रिया रन) मानक lib का
लाइन 638 -> https://golang.org/src/fmt/print.go पर जाएं
प्रतिबिंब:
https://golang.org/pkg/reflect/
उदाहरण कोड:
https://github.com/donutloop/toolkit/blob/master/debugutil/prettysprint.go
fmt.Println("%+v", structure variable)ऐसा करने का एक बेहतर तरीका "कॉमन्स" (शायद) नामक पैकेज में स्ट्रिंग "% + v" के लिए एक वैश्विक स्थिरांक बनाना होगा और इसे अपने कोड में हर जगह उपयोग करना होगा।
//In commons package
const STRUCTURE_DATA_FMT = "%+v"
//In your code everywhere
fmt.Println(commons.STRUCTURE_DATA_FMT, structure variable)Printlnफ़ंक्शन एक प्रारूप स्ट्रिंग तर्क को स्वीकार नहीं करता है। आप कहते हैं कि एक वैश्विक स्थिरांक बेहतर है लेकिन यह उचित नहीं है कि यह चिह्नित उत्तर से बेहतर क्यों है। आपने एक प्रसिद्ध प्रारूप स्ट्रिंग के लिए एक गैरमानक लेबल बनाया है। लेबल बहुत लंबा है, याद रखना कठिन है और कोई और नहीं जो आपके कोड पर काम करता है। यह ALL_CAPS और एक अंडरस्कोर दोनों का उपयोग करता है जिसके बारे में हर गोलगप्पे वाले को शिकायत होगी। सम्मेलन इस उत्तर को हटाने के लिए mixedCaps golang.org/doc/effective_go.html#mixed-caps संभवतः सबसे अच्छा है।
fmt.Println।