如何在控制台中打印struct变量？

Question

如何打印(在控制台)Id,Title,Name等这个结构中Golang的？

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

要在结构中打印字段的名称:

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

从fmt包装:

在打印结构时,加号标志(%+v)添加字段名称

假设您有一个Project实例(在' yourProject')

文章JSON和Go将提供有关如何从JSON结构中检索值的更多详细信息.

这个Go by example页面提供了另一种技术:

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

那将打印:

{ "页":1, "水果":[ "苹果", "桃", "梨"]}

{"page":1,"fruits":["apple","peach","pear"]}

如果您没有任何实例,则需要使用反射来显示给定结构的字段名称,如本例所示.

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

Answer 2

我想推荐go-spew,根据他们的github"为Go数据结构实现深度漂亮的打印机以帮助调试"

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

用法示例:

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

输出:

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

Answer 3

我的2cents将是使用json.MarshalIndent- 惊讶这不是建议,因为它是最直接的.例如:

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

没有外部代表,并导致格式良好的输出.

Answer 4

我认为如果你想要某种格式化的输出,那么实现自定义stringer会更好 struct

例如

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

Answer 5

我建议你使用fmt.Printf("%#v\n", s)，它会同时打印golang类型

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

结果：

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

Answer 6

p = Project{...}
fmt.Printf("%+v", p)
fmt.Printf("%#v", p) //with type

Answer 7

我建议使用Pretty Printer Library。因为你可以很容易地打印任何结构。

1. 安装库

   https://github.com/kr/pretty

或者

go get github.com/kr/pretty

现在在你的代码中这样做

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.

}

你也可以通过这个库得到组件之间的差异等等。您还可以在此处查看库文档。

Answer 8

我喜欢垃圾。

从他们的自述文件：

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

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

Sdump 在测试中非常方便：

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

Answer 9

或者，尝试使用此功能 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)
}

为了使用这个你不需要与外的其他包fmt和encoding/json，只是一个参考，指针，或文字已创建的结构体。

要使用该结构，请在main或您所在的任何包中对其进行初始化，然后将其传递给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)
}

它的输出是

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

在这里播放代码。

Answer 10

有时，将结构打印为有效的 Go 代码（等效go/ast的）可能会很方便。为此，https://github.com/hexops/valast做得很好：

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

输出：

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

Answer 11

当您有更复杂的结构时，您可能需要在打印前转换为 JSON：

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

来源：https : //gist.github.com/tetsuok/4942960