Wie kann man Strukturvariablen in der Konsole drucken?

Ich möchte go-spew empfehlen, das laut Github "Einen tiefen, hübschen Drucker für Go-Datenstrukturen implementiert, um das Debuggen zu unterstützen"

go get -u github.com/davecgh/go-spew/spew

anwendungsbeispiel:

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

ausgabe:

(main.Project) {
 Id: (int64) 0,
 Title: (string) (len=5) "world",
 Name: (string) (len=5) "hello",
 Data: (string) "",
 Commits: (string) ""
}

meine 2 Cent wäre json.MarshalIndent - überrascht, dass dies nicht empfohlen wird, da es am einfachsten ist. zum Beispiel:

func prettyPrint(i interface{}) string {
    s, _ := json.MarshalIndent(i, "", "\t")
    return string(s)
}

keine externen deps und führt zu einer schön formatierten Ausgabe.

Ich denke, es wäre besser, einen benutzerdefinierten Stringer zu implementieren, wenn Sie eine formatierte Ausgabe einer struct wünschen.

zum Beispiel

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 type

Besuchen Sie here , um den vollständigen Code zu sehen. Hier finden Sie auch einen Link für ein Online-Terminal, wo der vollständige Code ausgeführt werden kann und das Programm darstellt, wie die Strukturinformationen extrahiert werden (Feldname, Typ und Wert). Nachfolgend finden Sie den Programmausschnitt, der nur die Feldnamen druckt.

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
*/

Ich mag Wurf .

Aus 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 in Tests ziemlich praktisch: 

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

Alternativ können Sie diese Funktion verwenden 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)
}

Um dies zu verwenden, benötigen Sie keine zusätzlichen Pakete mit Ausnahme von fmt und encoding/json, sondern lediglich eine Referenz, einen Zeiger oder ein Literal der von Ihnen erstellten Struktur.

Zur Verwendung nehmen Sie einfach Ihre Struktur, initialisieren Sie sie in main oder in einem anderen Paket und übergeben Sie sie an 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)
}

Die Ausgabe wäre

### struct as a pointer ###
{
    "Network": "10.1.1.0",
    "Mask": 24
} 

Spielen Sie mit dem Code herum hier .

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

1. Installieren Sie die Bibliothek

   https://github.com/kr/pretty

oder 

go get github.com/kr/pretty

So machen Sie das jetzt in Ihrem 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.

}

Außerdem können Sie durch diese Bibliothek Unterschiede zwischen den einzelnen Komponenten erhalten. Sie können sich auch die Bibliothek Docs hier anschauen.

Es gibt auch go-render , das die Zeigerrekursion und jede Menge Schlüsselsortierung für String- und Int-Maps behandelt. 

Installation:

go get github.com/luci/go-render/render

Beispiel:

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

Welche drucke:

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

Ohne Verwendung externer Bibliotheken und mit neuer Zeile nach jedem Feld:

log.Println(
            strings.Replace(
                fmt.Sprintf("%#v", post), ", ", "\n", -1))

Ich möchte Stuct Example GO Sprachprogramm mit einem Beispiel von Struc Type empfehlen.

 package main 

 import (
 "fmt" 
) 

 func main () {
 Typ Gehaltsstruktur {
 Basic, HRA, TA float64 
 } 

 Typ Mitarbeiterstruktur {
 Vorname, Nachname, E-Mail-Zeichenfolge 
 Alter int 
 MonthlySalary [] Gehalt 
 } 

 e: = Mitarbeiter {
 Vorname: "Mark", 
 Nachname: "Jones", 
 E-Mail: "[email protected]", 
 Alter: 25, 
 MonthlySalary: [] Gehalt {
 Gehalt{
 Basic: 15000.00, 
 HRA: 5000,00, 
 TA: 2000,00, 
 }, 
 Gehalt{
 Basic: 16000.00, 
 HRA: 5000,00, 
 TA: 2100.00, 
 }, 
 Gehalt{
 Basic: 17000.00, 
 HRA: 5000,00, 
 TA: 2200.00, 
 }, 
 }, 
 } 
 fmt.Println (e.FirstName, e.LastName) 
 fmt.Println (e.Age) 
 fmt.Println (e.Email) 
 fmt.Println (e.MonthlySalary [0]) 
 fmt.Println (e.MonthlySalary [1]) 
 fmt.Println (e.MonthlySalary [2]) 
} 

Eine andere Möglichkeit ist, eine Funktion mit dem Namen toString zu erstellen, die die Struktur nimmt. Formatieren Sie die Felder .__ nach Ihren Wünschen.

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

Wenn Sie komplexere Strukturen haben, müssen Sie möglicherweise vor dem Drucken in JSON konvertieren:

// Convert structs to JSON.
data, err := json.Marshal(myComplexStruct)
fmt.Printf("%s\n", data)

Quelle: https://Gist.github.com/tetsuok/4942960