Comment imprimer des variables struct dans la console?

Comment puis-je imprimer (dans la console) l’ Id , le Title , le Name , etc. de cette structure dans Golang?

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

Pour imprimer le nom des champs dans une structure:

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

À partir du paquetage fmt :

lors de l’impression de structs, le drapeau plus ( %+v ) ajoute des noms de champs

Cela suppose que vous avez une instance de Project (dans ‘ yourProject ‘)

L’article JSON et Go donnera plus de détails sur la manière de récupérer les valeurs d’une structure JSON.


Cette page Go by example fournit une autre technique:

 type Response2 struct { Page int `json:"page"` Fruits []ssortingng `json:"fruits"` } res2D := &Response2{ Page: 1, Fruits: []ssortingng{"apple", "peach", "pear"}} res2B, _ := json.Marshal(res2D) fmt.Println(ssortingng(res2B)) 

Cela imprimerait:

 {"Page":1,"Fruits":["apple","peach","pear"]} 

Si vous n’avez aucune instance, vous devez utiliser la reflection pour afficher le nom du champ d’une structure donnée, comme dans cet exemple .

 type T struct { A int B ssortingng } 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()) } 

Je tiens à recommander go-spew , qui selon leur github “Implémente une imprimante très jolie pour les structures de données Go pour faciliter le débogage”

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

exemple d’utilisation:

 package main import ( "github.com/davecgh/go-spew/spew" ) type Project struct { Id int64 `json:"project_id"` Title ssortingng `json:"title"` Name ssortingng `json:"name"` Data ssortingng `json:"data"` Commits ssortingng `json:"commits"` } func main() { o := Project{Name: "hello", Title: "world"} spew.Dump(o) } 

sortie:

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

Je pense qu’il serait préférable d’implémenter un ssortingnger personnalisé si vous voulez une sorte de sortie formatée d’une struct

par exemple

 package main import "fmt" type Project struct { Id int64 `json:"project_id"` Title ssortingng `json:"title"` Name ssortingng `json:"name"` } func (p Project) Ssortingng() ssortingng { 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 

mes 2cents seraient d’utiliser json.MarshalIndent – surpris que ce n’est pas suggéré, car c’est le plus simple. par exemple:

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

pas de deps externes et donne une sortie bien formatée.

Visitez ici pour voir le code complet. Vous trouverez également ici un lien vers un terminal en ligne où le code complet peut être exécuté et le programme représente comment extraire les informations de la structure (nom du champ, son type et sa valeur). Voici l’extrait de programme qui imprime uniquement les noms de champs.

 package main import "fmt" import "reflect" func main() { type Book struct { Id int Name ssortingng Title ssortingng } 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 */ 

Il y a aussi go-render , qui gère la récursion du pointeur et beaucoup de sorting pour les cartes ssortingng et int.

Installation:

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

Exemple:

 type customType int type testStruct struct { S ssortingng V *map[ssortingng]int I interface{} } a := testStruct{ S: "hello", V: &map[ssortingng]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)) 

Quelles impressions:

 fmt.Printf: render.testStruct{S:"hello", V:(*map[ssortingng]int)(0x600dd065), I:42} render.Render: render.testStruct{S:"hello", V:(*map[ssortingng]int){"bar":1, "foo":0}, I:render.customType(42)} 

Une autre méthode consiste à créer une fonction appelée toSsortingng qui prend en charge struct, formatez les champs comme vous le souhaitez.

 import ( "fmt" ) type T struct { x, y ssortingng } func (r T) toSsortingng() ssortingng { return "Formate as u need :" + rx + ry } func main() { r1 := T{"csa", "ac"} fmt.Println("toSsortingnged : ", r1.toSsortingng()) } 

Je souhaite recommander Stuct Example GO language program avec un exemple de Struc Type.

 paquet principal

 importation (
 "fmt"
 )

 func main () {
     type Salary struct {
         Basique, HRA, TA float64      
     }

     type Employee struct {
         Prénom, Nom, Chaîne de messagerie
         Age int
         MonthlySalary [] Salaire
     }

     e: = employé {
         Prénom: "Mark",
         Nom: "Jones",
         Email: "mark@gmail.com",
         Age: 25 ans
         MonthlySalary: [] Salaire {
             Un salaire{
                 Basic: 15000.00,
                 HRA: 5000.00,
                 TA: 2000.00,
             },
             Un salaire{
                 Basic: 16000.00,
                 HRA: 5000.00,
                 TA: 2100.00,
             },
             Un salaire{
                 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])
 }

Sans utiliser de bibliothèques externes et avec une nouvelle ligne après chaque champ:

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

J’aime la litière .

De leur readme:

 type Person struct { Name ssortingng Age int Parent *Person } litter.Dump(Person{ Name: "Bob", Age: 20, Parent: &Person{ Name: "Jane", Age: 50, }, }) 

Sdump est très pratique dans les 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) } } 

Lorsque vous avez des structures plus complexes, vous devrez peut-être convertir en JSON avant d’imprimer:

 // Convert structs to JSON. data, err := json.Marshal(myComplexStruct) if err != nil { log.Fatal( } fmt.Printf("%s\n", data) 

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