web-dev-qa-db-ja.com

コンソールで構造体変数を表示する方法

Golangでこの構造体のIdTitleNameなどを(コンソールで)印刷するにはどうすればいいですか?

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

構造体のフィールドの名前を印刷するには:

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

fmtパッケージ から:

構造体を印刷するとき、プラスフラグ(%+v)はフィールド名を追加します

Projectのインスタンスがあると仮定します( 'yourProject'に)

記事 JSON and 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"]}

インスタンスがない場合は、反射を使用で特定のフィールドの名前を表示する必要がありますstruct、 この例のように

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

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) ""
}
92
Martin Olika

私の2centsはjson.MarshalIndentを使うことになるでしょう - 驚いたのは、これが最も簡単なので提案されていないことです。例えば:

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

外部のデプスはなく、きれいにフォーマットされた出力になります。

42
mad.meesh

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)
    }
14
Vivek Maru
p = Project{...}
fmt.Printf("%+v", p)
fmt.Printf("%#v", p) //with type
12
cokeboL

完全なコードを見るには ここ にアクセスしてください。ここには、完全なコードを実行することができ、プログラムが構造体の情報(フィールドの名前とその種類と値)を抽出する方法を表すオンライン端末へのリンクもあります。以下は、フィールド名だけを表示するプログラムスニペットです。

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

私は Litter が好きです。

彼らの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)
  }
}
3
qed

または、この関数を使用してみてください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)
}

これを使用するために、fmtencoding/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
} 

コードで試してみてください here

3
Erik Toor

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.

}

また、あなたはこのライブラリなどを通じてコン​​ポーネント間の違いを得ることができます。 library Docs を見てみることもできます。

2
amku91

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

より複雑な構造がある場合は、印刷する前にJSONに変換する必要があります。

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

ソース: https://Gist.github.com/tetsuok/4942960

1
Cassio

外部ライブラリを使用せずに各フィールドの後に新しい行を追加します。

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

Stuct Example Struc Typeの例を​​含む/ GO言語プログラムをお勧めします。

 package main 
 
 import(
 "fmt" 
)
 
 func main(){[。 ____。タイプ給与構造体{
基本、HRA、TA float64 
} 
 
タイプ従業員構造体{
 FirstName、LastName、Email文字列[ Age int 
 MonthlySalary [] Salary 
} 
 
 e:=従業員{
 FirstName: "Mark"、
 LastName: "Jones"、
 Email: "[email protected]"、
年齢:25、
 MonthlySalary:[]給与{
給与{ 
基本:15000.00、
 HRA:5000.00、
 TA:2000.00、
}、
給与{
基本:16000.00、 
 HRA:5000.00、
 TA:2100.00、
}、
給与{
基本:17000.00、
 HRA:5000.00、 
 TA: 2200.00、
]、
}、
} 
 fmt.Println(e.FirstName、e.LastName)
 fmt.Println(e。年齢)
 fmt.Println(e.Email)
 fmt.Println(e.MonthlySalary [0])
 fmt.Println(e.MonthlySalary [1])[.____ 。fmt.Println(e.MonthlySalary [2])
} 
0
Amit Arora

もう1つの方法は、structを取る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())
}
0
pschilakanti