Wie druckt man Strukturvariablen in der Konsole aus?

Question

Wie kann ich (auf der Konsole) das Id, Title, Name, usw. dieser Struktur in Golang ausgeben?

type Project struct {
    Id      int64   `json:"project_id"`
    Title   string  `json:"title"`
    Name    string  `json:"name"`
    Data    Data    `json:"data"`
    Commits Commits `json:"commits"`
}

Answer 1

p = Projekt{...}
fmt.Printf("%+v", p)
fmt.Printf("%#v", p) //mit Typ

Answer 2

Ich schlage vor, fmt.Printf("%#v\n", s) zu verwenden, es wird den Golang-Typ gleichzeitig drucken

package main

import (
    "fmt"
    "testing"
)

type student struct {
    id   int32
    name string
}

type Project struct {
    Id      int64   `json:"project_id"`
    Title   string  `json:"title"`
    Name    string  `json:"name"`
}

func TestPrint(t *testing.T) {
    s := Project{1, "title","jack"}
    fmt.Printf("%+v\n", s)
    fmt.Printf("%#v\n", s)
}

Ergebnis:

{Id:1 Title:title Name:jack}
main.Project{Id:1, Title:"title", Name:"jack"}

Answer 3

Ich empfehle die Verwendung der Pretty Printer Library. Damit können Sie sehr einfach jede Struktur drucken.

1. Bibliothek installieren

   https://github.com/kr/pretty

oder

go get github.com/kr/pretty

Führen Sie jetzt in Ihrem Code folgendes aus

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)) //Es werden alle Strukturdetails gedruckt

fmt.Printf("%# v", pretty.Formatter(Project.Id)) //Es wird Komponente für Komponente gedruckt.

}

Sie können auch Unterschiede zwischen den Komponenten über diese Bibliothek erhalten und vieles mehr. Hier können Sie sich auch die Dokumentation der Bibliothek ansehen.

Answer 4

Ich mag litter.

Von ihrem Readme:

type Person struct {
  Name   string
  Age    int
  Parent *Person
}

litter.Dump(Person{
  Name:   "Bob",
  Age:    20,
  Parent: &Person{
    Name: "Jane",
    Age:  50,
  },
})

Sdump ist ziemlich praktisch in Tests:

func TestSearch(t *testing.T) {
  result := DoSearch()

  actual := litterOpts.Sdump(result)
  expected, err := ioutil.ReadFile("testdata.txt")
  if err != nil {
    // Erster Durchlauf, Schreibtestdaten, da sie nicht existieren
        if !os.IsNotExist(err) {
      t.Error(err)
    }
    ioutil.Write("testdata.txt", actual, 0644)
    actual = expected
  }
  if expected != actual {
    t.Errorf("Erwartet %s, erhalten %s", expected, actual)
  }
}

Answer 5

Manchmal kann es nützlich sein, die Struktur als gültigen Go-Code (das go/ast-Äquivalent) auszugeben. Zu diesem Zweck erledigt https://github.com/hexops/valast gute Arbeit:

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

Ausgabe:

go run main.go 
Project{Id: 1, Data: &ProjectData{
        Title:   "Test",
        Name:    "Mihai",
        Data:    "Some data",
        Commits: "Test Message",
}}