如何在控制台打印结构变量?

小开

最佳答案

打印结构中字段的名称:

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

# EYZ0包:

打印结构体时，加号标记(%+v)添加字段名

这假设你有一个项目的实例(在“yourProject”中)

文章JSON和Go将详细介绍如何从JSON结构中检索值。

浏览示例页面提供了另一种技术:

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

这将打印:

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

小开

我想推荐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) ""
}

小开

还有go-render，它处理指针递归和字符串和int映射的大量键排序。

安装:

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

例子:

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

打印:

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

小开

访问在这里查看完整的代码。在这里你还可以找到一个在线终端的链接，在那里可以运行完整的代码，程序表示如何提取结构的信息(字段的名称，类型&值)。下面是只打印字段名的程序片段。

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

小开

我认为，如果您想要某种格式的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)
}

小开

另一种方法是，创建一个名为toString的func，它接受struct，格式化

.

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

小开

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

小开

不使用外部库，每个字段后加新行:

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

小开

我喜欢垃圾。

从他们的自述:

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

小开

我的2美分建议使用json.MarshalIndent——很惊讶这没有被建议，因为它是最直接的。例如:

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

没有外部deps，结果输出格式很好。

小开

当你有更复杂的结构时，你可能需要在打印之前转换成JSON:

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

来源:# EYZ0

小开

我建议使用漂亮的打印机库。这样你可以很容易地打印任何结构体。

< p >安装库

# EYZ0 < / p >

或

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.


}

此外，您还可以通过这个库获取组件之间的差异等等。你也可以看一下文档库。

小开

fmt.Println("%+v", structure variable)

更好的方法是在名为“commons”(可能)的包中为字符串“%+v”创建一个全局常量，并在代码中处处使用它

//In commons package
const STRUCTURE_DATA_FMT = "%+v"


//In your code everywhere
fmt.Println(commons.STRUCTURE_DATA_FMT, structure variable)

小开

或者，尝试使用这个函数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
}

使用代码在这里。

小开

这些包中的大多数都依赖于reflect包来实现这些功能。

# EYZ0

fmt.Sprintf()正在使用-> func (p *pp) printArg(参数接口{}，动词符文)的标准库

转到第638行-> https://golang.org/src/fmt/print.go

反射:

https://golang.org/pkg/reflect/

示例代码:

https://github.com/donutloop/toolkit/blob/master/debugutil/prettysprint.go

小开

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

这是打印细节的基本方法

小开

    type Response struct {
UserId int    `json:"userId"`
Id     int    `json:"id"`
Title  string `json:"title"`
Body   string `json:"body"`
}


func PostsGet() gin.HandlerFunc {
return func(c *gin.Context) {
xs, err := http.Get("https://jsonplaceholder.typicode.com/posts")
if err != nil {
log.Println("The HTTP request failed with error: ", err)
}
data, _ := ioutil.ReadAll(xs`enter code here`.Body)




// this will print the struct in console
fmt.Println(string(data))




// this is to send as response for the API
bytes := []byte(string(data))
var res []Response
json.Unmarshal(bytes, &res)


c.JSON(http.StatusOK, res)
}
}

小开

< p >非常简单我没有数据和提交的结构，所以我改变了

package main


import (
"fmt"
)


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() {
p := Project{
1,
"First",
"Ankit",
"your data",
"Commit message",
}
fmt.Println(p)
}

要学习你可以从这里获得帮助:https://gobyexample.com/structs

小开

也许这不应该应用于生产请求，但如果您处于调试模式，我建议您遵循以下方法。

marshalledText, _ := json.MarshalIndent(inputStruct, "", " ")
fmt.Println(string(marshalledText))

这将导致以json格式格式化数据，增加可读性。

小开

打印JSON格式的结构体:

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

也可以用(如上所述):

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

但是第二个选项打印的字符串值不带"所以很难读懂。

小开

如果您想写入日志文件，就像我之前搜索的那样。那么你应该使用:

log.Infof("Information %+v", structure)

注意::这将不会与< >强日志。信息或日志。调试< / >强工作。在这种情况下，"%v"将被打印，结构的所有值将被打印，而不打印键/变量名。

小开

使用包fmt输出非常方便:

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

如果你想看到完整的sturct类型，你可以使用# replace +:

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

小开

有时，将结构体打印为有效的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",
}}

小开

您可以先执行json mashal并将其作为字符串打印。你可以看到整个struct的值。

package main


import "fmt"
import "json"


type Project struct {
Id int64 `json:"project_id"`
Title string `json:"title"`
Name string `json:"name"`
}


func main() {
o := Project{Id: 4, Name: "hello", Title: "world"}
om, _ := json.marshal(o)
log.Printf("%s\n", string(om))
}

小开

一个简单的问题有很多答案。我还不如参加竞选呢。

package main


import "fmt"


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


var (
Testy Project
)


func dump_project(foo Project) {
fmt.Println("== Dump Project Struct ====")
fmt.Printf("Id: %d\n", foo.Id)
fmt.Println("Title: ", foo.Title)
fmt.Printf("Name: %v\n", foo.Name)
}


func main() {
fmt.Println("hello from go")
Testy.Id = 3
Testy.Title = "yo"
Testy.Name = "my name"
fmt.Println(Testy)
dump_project(Testy)
}

输出的各种打印方法

hello from go
{3 yo my name}
== Dump Project Struct ====
Id: 3
Title:  yo
Name: my name

小开

我建议使用json.Unmarshal() 我试着打印id，希望它有帮助:

var jsonString = `{"Id": 1, "Title": "the title", "Name": "the name","Data": "the data","Commits" : "the 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)

小开

我建议你使用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"}