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

Wenn Sie komplexere Strukturen haben, müssen Sie möglicherweise in JSON konvertieren, bevor Sie drucken:

// Strukturen in JSON konvertieren.
data, err := json.Marshal(myComplexStruct)
fmt.Printf("%s\n", data)

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

Answer 2

Besuchen Sie hier, um den vollständigen Code zu sehen. Hier finden Sie auch einen Link zu einem Online-Terminal, in dem der vollständige Code ausgeführt werden kann. Das Programm zeigt, wie Informationen zur Struktur (Feldnamen, Typ und Wert) extrahiert werden können. Unten ist der Programmausschnitt, der nur die Feldnamen ausgibt.

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

Answer 3

Hier ist ein Beispiel, das die Verwendung von Formatierungsspezifikatoren %d, %t und %s für jeden integrierten Typ in Go wie: int, string, bool, struct und interface demonstriert.

package main

import "fmt"

// Definiere eine Struktur
type Person struct {
    Name string
    Age  int
}

// Definiere eine Schnittstelle
type Describer interface {
    Describe() string
}

// Implementiere die Schnittstelle Describer für Person
func (p Person) Describe() string {
    return fmt.Sprintf("Name: %s, Age: %d", p.Name, p.Age)
}

func main() {
    // Integer
    intVar := 42
    fmt.Printf("Integer %%d: %d\n", intVar)

    // Boolean
    boolVar := true
    fmt.Printf("Boolean %%t: %t\n", boolVar)

    // String
    strVar := "Hello, Go!"
    fmt.Printf("String %%s: %s\n", strVar)

    // Struct
    person := Person{Name: "Alice", Age: 30}
    fmt.Printf("Struct %%+v: %+v\n", person)

    // Interface
    var describer Describer
    describer = person
    fmt.Printf("Interface %%s: %s\n", describer.Describe())
}

In diesem Beispiel wird jeder Typ mithilfe der angegebenen Formatierungsspezifikatoren gedruckt.

%d ist für ganze Zahlen

%t ist für Booleans

%s ist für Strings

%+v ist für Strukturen, die Feldnamen sowie Werte anzeigen

Ich hoffe, das ist hilfreich für Sie. Für weitere Details können Sie diesen Blog Exploring Built-in Types in Go lesen

Answer 4

Ich schlage vor, json.Unmarshal() zu verwenden Ich versuche, die ID mit der Hoffnung zu drucken, dass es hilfreich ist:

var jsonString = `{"Id": 1, "Title": "der Titel", "Name": "der Name","Data": "die Daten","Commits" : "die Commits"}`
var jsonData = []byte(jsonString)

var data Project

var err = json.Unmarshal(jsonData, &data)
if err != nil {
    fmt.Println(err.Error())
    return
}

fmt.Println("Id :", data.Id)

Answer 5

Es gibt auch go-render, das Rekursion von Pointern und Sortieren von Schlüsseln für String- und Integer-Maps handhabt.

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

Das gibt aus:

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