Hoe kan ik (naar de console) de Id, Title, Name, enz. van deze struct in Golang afdrukken?
type Project struct {
Id int64 `json:"project_id"`
Title string `json:"title"`
Name string `json:"name"`
Data Data `json:"data"`
Commits Commits `json:"commits"`
}
Antwoord 1, autoriteit 100%
Om de naam van de velden in een structuur af te drukken:
fmt.Printf("%+v\n", yourProject)
Van het fmt-pakket:
bij het afdrukken van structs voegt de plus-vlag (
%+v) veldnamen toe
Dat veronderstelt dat je een instantie van Project hebt (in ‘yourProject‘)
Het artikel JSON and Gogeeft meer details over het ophalen van de waarden van een JSON-struct.
Deze Bekijk voorbeeldpaginabiedt een andere techniek:
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))
Dat zou afdrukken:
{"page":1,"fruits":["apple","peach","pear"]}
Als je geen instantie hebt, moet je reflectie gebruikenom de naam van het veld van een bepaalde struct weer te geven, zoals in dit voorbeeld.
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())
}
Antwoord 2, autoriteit 19%
Ik wil go-spewaanbevelen, die volgens hun github “een diepe mooie printer implementeert voor Go-gegevensstructuren om te helpen bij het debuggen”
go get -u github.com/davecgh/go-spew/spew
gebruiksvoorbeeld:
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)
}
uitvoer:
(main.Project) {
Id: (int64) 0,
Title: (string) (len=5) "world",
Name: (string) (len=5) "hello",
Data: (string) "",
Commits: (string) ""
}
Antwoord 3, autoriteit 17%
mijn 2 cent zou zijn om json.MarshalIndentte gebruiken — het verbaast me dat dit niet wordt gesuggereerd, omdat dit het meest rechttoe rechtaan is. bijvoorbeeld:
func prettyPrint(i interface{}) string {
s, _ := json.MarshalIndent(i, "", "\t")
return string(s)
}
geen externe deps en resulteert in mooi opgemaakte uitvoer.
Antwoord 4, autoriteit 4%
Ik denk dat het beter is om een aangepaste stringer te implementeren als je een soort geformatteerde uitvoer van een struct
wilt
bijvoorbeeld
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)
}
Antwoord 5, autoriteit 3%
p = Project{...}
fmt.Printf("%+v", p)
fmt.Printf("%#v", p) //with type
Antwoord 6, autoriteit 3%
U kunt ook deze functie gebruiken 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)
}
Om dit te gebruiken heb je geen extra pakketten nodig, met uitzondering van fmten encoding/json, alleen een verwijzing, verwijzing naar of letterlijk van de structuur die u hebt gemaakt.
Om te gebruiken neem je gewoon je struct, initialiseer je het in het hoofdpakket of in welk pakket je ook zit en geef je het door aan 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)
}
De output zou zijn
### struct as a pointer ###
{
"Network": "10.1.1.0",
"Mask": 24
}
Speel hierwat rond met de code.
Antwoord 7
Ik raad aan om Pretty Printer Libraryte gebruiken. Daarin kun je elke structuur heel gemakkelijk afdrukken.
-
Bibliotheek installeren
of
go get github.com/kr/pretty
Doe nu zo in je code
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.
}
U kunt via deze bibliotheek ook verschil tussen componenten krijgen en meer. Je kunt hier ook de bibliotheek Documentenbekijken.
Antwoord 8
Ik hou van nest.
Uit hun leesmij:
type Person struct {
Name string
Age int
Parent *Person
}
litter.Dump(Person{
Name: "Bob",
Age: 20,
Parent: &Person{
Name: "Jane",
Age: 50,
},
})
Sdumpis best handig in tests:
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)
}
}
Antwoord 9
Het is erg handig om pakket fmt te gebruiken om uit te voeren:
fmt.Printf("%+v \n", yourProject)
als u het volledige type van de structuur wilt zien, kunt u # vervangen + :
gebruiken
fmt.Printf("%#v \n", yourProject)
Antwoord 10
Om de struct af te drukken als JSON:
fmt.Printf("%#v\n", yourProject)
Ook mogelijk met (zoals hierboven vermeld):
fmt.Printf("%+v\n", yourProject)
Maar de tweede optie drukt tekenreekswaarden af zonder “” zodat het moeilijker te lezen is.
Antwoord 11
Als u complexere structuren heeft, moet u mogelijk converteren naar JSON voordat u gaat afdrukken:
// Convert structs to JSON.
data, err := json.Marshal(myComplexStruct)
fmt.Printf("%s\n", data)
Bron: https://gist.github.com/tetsuok/4942960
Antwoord 12
Soms kan het handig zijn om de struct af te drukken als geldige Go-code (het go/astequivalent). Voor dit doel doet https://github.com/hexops/valastgeweldig werk:
package main
import (
"fmt"
"github.com/hexops/valast"
)
type ProjectData struct {
Title string `json:"title"`
Name string `json:"name"`
Data string `json:"data"`
Commits string `json:"commits"`
}
type Project struct {
Id int64 `json:"project_id"`
Data *ProjectData `json:"data"`
}
func main() {
p := Project{
Id: 1,
Data: &ProjectData{
Title: "Test",
Name: "Mihai",
Data: "Some data",
Commits: "Test Message",
},
}
fmt.Println(valast.String(p))
}
Uitvoer:
go run main.go
Project{Id: 1, Data: &ProjectData{
Title: "Test",
Name: "Mihai",
Data: "Some data",
Commits: "Test Message",
}}
Antwoord 13
Bezoek hierom de volledige code te zien. Hier vindt u ook een link voor een online terminal waar de volledige code kan worden uitgevoerd en het programma vertegenwoordigt hoe de informatie van de structuur kan worden geëxtraheerd (veldnaam hun type en waarde). Hieronder staat het programmafragment dat alleen de veldnamen afdrukt.
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
*/
Antwoord 14
Je kunt eerst de json mashal doen en deze als een string afdrukken. Daar kun je de hele structuurwaarde volledig zien.
package main
import "fmt"
import "json"
type Project struct {
Id int64 `json:"project_id"`
Title string `json:"title"`
Name string `json:"name"`
}
func main() {
o := Project{Id: 4, Name: "hello", Title: "world"}
om, _ := json.marshal(o)
log.Printf("%s\n", string(om))
}
Antwoord 15
Misschien zou dit niet moeten worden toegepast voor productieverzoeken, maar als je in de foutopsporingsmodus bent, raad ik je aan de onderstaande aanpak te volgen.
marshalledText, _ := json.MarshalIndent(inputStruct, "", " ")
fmt.Println(string(marshalledText))
Dit resulteert in het formatteren van de gegevens in json-formaat met verhoogde leesbaarheid.
Antwoord 16
Er is ook go-render, die pointer-recursie en veel sleutelsortering voor string en int kaarten.
Installatie:
go get github.com/luci/go-render/render
Voorbeeld:
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))
Welke afdrukken:
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)}
Antwoord 17
fmt.Printf("%+v\n", project)
Dit is de basismanier om de details af te drukken
Antwoord 18
Zonder gebruik te maken van externe bibliotheken en met een nieuwe regel na elk veld:
log.Println(
strings.Replace(
fmt.Sprintf("%#v", post), ", ", "\n", -1))
Antwoord 19
heel eenvoudig
Ik heb de structuur van gegevens en verplichtingen niet, dus ik heb de
. gewijzigd
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)
}
Voor het leren kun je hier hulp krijgen: https://gobyexample.com/structs
Antwoord 20
Als je in een logbestand wilt schrijven, zoals ik eerder aan het zoeken was. Gebruik dan:
log.Infof("Information %+v", structure)
Opmerking:: dit werkt niet met log.Info of log.Debug. In dit geval wordt “%v” afgedrukt en worden alle waarden van de structuur afgedrukt zonder de naam van de sleutel/variabele af te drukken.
Antwoord 21
Een andere manier is, maak een func genaamd toStringdie struct aanneemt, formatteer de
velden naar wens.
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())
}
Antwoord 22
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)
}
}
Antwoord 23
De meeste van deze pakketten vertrouwen op het reflect-pakket om dergelijke dingen mogelijk te maken.
fmt.Sprintf() gebruikt -> func (p *pp) printArg(arg interface{}, werkwoord rune) van standaard lib
Ga naar regel 638 -> https://golang.org/src/fmt/print.go
Reflectie:
https://golang.org/pkg/reflect/
Voorbeeldcode:
https://github.com/donutloop/toolkit/blob /master/debugutil/prettysprint.go
Antwoord 24
fmt.Println("%+v", structure variable)
Een betere manier om dit te doen is door een globale constante te maken voor de string “%+v” in een pakket met de naam “commons”(misschien) en deze overal in uw code te gebruiken
//In commons package
const STRUCTURE_DATA_FMT = "%+v"
//In your code everywhere
fmt.Println(commons.STRUCTURE_DATA_FMT, structure variable)