it-swarm.com.de

Wie kann man Strukturvariablen in der Konsole drucken?

Wie kann ich (in der Konsole) die Id, Title, Name usw. dieser Struktur in Golang drucken?

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

So drucken Sie den Namen der Felder in einer Struktur:

fmt.Printf("%+v\n", yourProject)

Aus dem fmt-Paket :

beim Drucken von Strukturen fügt das Pluszeichen (%+v) Feldnamen hinzu

Angenommen, Sie haben eine Instanz von Project (in 'yourProject')

Der Artikel JSON und Go enthält weitere Informationen zum Abrufen der Werte aus einer JSON-Struktur.


Diese Go by Beispielseite bietet eine andere Technik:

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

Das würde drucken:

{"Seite": 1, "Früchte": ["Apfel", "Pfirsich", "Birne"]}
{"page":1,"fruits":["Apple","Peach","pear"]}

Wenn Sie keine Instanz haben, müssen Sie Reflection verwenden, um den Namen des Felds einer gegebenen Struktur anzuzeigen, wie in diesem Beispiel .

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

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) ""
}
82
Martin Olika

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.

26
mad.meesh

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)
    }
11
Vivek Maru
p = Project{...}
fmt.Printf("%+v", p)
fmt.Printf("%#v", p) //with type
9
cokeboL

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

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

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 .

3
Erik Toor

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.

2
amku91

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

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

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

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]) 
} 
0
Amit Arora

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

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

0
Cassio