Как печатать переменные структуры в консоли?

Я хочу порекомендовать 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) ""
}

Я думаю, что было бы лучше, чтобы реализовать пользовательский Стрингер если вы хотите какой-то форматированный вывод 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)
    }

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

мои 2cents будет использовать json.MarshalIndent -- удивлен, что это не предлагается, так как это самый простой. например:

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

нет внешних deps и приводит к красиво отформатированный вывод.

посетить здесь чтобы увидеть полный код. Здесь вы также найдете ссылку на онлайн-терминал, где можно запустить полный код, и программа представляет, как извлечь информацию о структуре(имя поля их тип и значение). Ниже приведен фрагмент программы, который печатает только имена полей.

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

Я рекомендую использовать Довольно Библиотека Принтера. В этом вы можете распечатать любую структуру очень легко.

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.

}

Также вы можете получить разницу между компонента через эту библиотеку и так далее. Вы также можете посмотреть на библиотеку Docs здесь.

там же 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)}

мне нравится сори.

из их readme:

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

другой способ, создать функцию под названием toString, которая принимает структуру, формат поля, как вы хотите.

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

Я хочу порекомендовать Пример Stuct перейти язык программы с примером типа структуры.

package main

import (
"fmt"
)

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

    type Employee struct{
        FirstName, LastName, Email string
        Age int
        MonthlySalary []Salary
    }

    e := Employee{
        FirstName: "Mark",
        LastName: "Jones",
        Email: "[email protected]",
        Age: 25,
        MonthlySalary: []Salary{
            Salary{
                Basic:15000.00,
                HRA:5000.00,
                TA:2000.00,
            },
            Salary{
                Basic:16000.00,
                HRA:5000.00,
                TA:2100.00,
            },
            Salary{
                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])
}

без использования внешних библиотек и с новой строки после каждого поля:

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

Если у вас есть более сложные структуры, Вам может потребоваться преобразовать в JSON перед печатью:

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

Источник:https://gist.github.com/tetsuok/4942960