浅谈Golang格式化打印

梦里梦外; 2022-09-10 12:21 17阅读 0赞

# 前言 #

不管是为了调试，还是为了啥。我们在工作中经常会需要对结构体或一些值啥的进行打印，一个pretty的打印格式能够给我们带来良好的心情，关键是可以提高我们调试的效率，一下就看到哪里出了问题。那么我们可以咋么来打印呢？

我们先随便搞个结构体吧：

package demo
    
    import (
    	"time"
    )
    
    type Gender int
    
    const (
    	Male Gender = iota
    	Female
    )
    
    type User struct {
        
    	Name string
    	Age  int
    	Gender
    	Address      string
    	BirthDate    time.Time
    	Introduction string
    	Fellow       *User
    }

# 几种打印方式 #

## printf ##

最基础的一种方式就是使用fmt的printf系列函数来打印，我们来看看几个最常用的方式打印出来的效果：

example := &User{
        
    		Name:         "string",
    		Age:          26,
    		Gender:       Male,
    		Address:      "this is my home street",
    		BirthDate:    time.Now().UTC(),
    		Introduction: "I'm a happy boy. I like playing guitar.",
    		Fellow: &User{
        
    			Name:         "son",
    			Age:          1,
    			Gender:       Male,
    			Address:      "same with string",
    			BirthDate:    time.Now().Add(-5 * time.Second),
    			Introduction: "son of string",
    		}}
    	fmt.Printf("%v\n%+v\n%#+v\n", example, example, example)

输出：

&{
        string 26 0 this is my home street 2021-09-23 16:43:07.844691 +0000 UTC I'm a happy boy. I like playing guitar. 0xc0000a2240}
    &{Name:string Age:26 Gender:0 Address:this is my home street BirthDate:2021-09-23 16:43:07.844691 +0000 UTC Introduction:I'm a happy boy. I like playing guitar. Fellow:0xc0000a2240}
    &demo.User{
        Name:"string", Age:26, Gender:0, Address:"this is my home street", BirthDate:time.Time{
        wall:0x3258f638, ext:63768012187, loc:(*time.Location)(nil)}, Introduction:"I'm a happy boy. I like playing guitar.", Fellow:(*demo.User)(0xc0000a2240)}

可以看到

*  %v以很简略的方式打出了所有字段，字段名没有，类型名没有，字段之间也没有分割，实在是简约过头了。
 *  \+v把字段名给打出来了，但是也不会继续展开其中的指针，并且也没有类型名。
 *  \#+v倒是即有UserName，又有类型名了，但它还是没有展开指针。然后不该展开的，比如BirthDate的time.Time类型就瞎展开，明明原来那个格式好。

要是是指针数组就更扯淡了：

var example = []*User{
        {
        
    	Name:         "string",
    	Age:          26,
    	Gender:       Male,
    	Address:      "this is my home street",
    	BirthDate:    time.Now().UTC(),
    	Introduction: "I'm a happy boy. I like playing guitar.",
    	Fellow: &User{
        
    		Name:         "son",
    		Age:          1,
    		Gender:       Male,
    		Address:      "same with string",
    		BirthDate:    time.Now().Add(-5 * time.Second),
    		Introduction: "son of string",
    	},
    }, {
        
    	Name:         "lemon",
    	Age:          27,
    	Gender:       Male,
    	Address:      "this is my girl",
    	BirthDate:    time.Now().UTC(),
    	Introduction: "I'm a happy girl. I gogogo me.",
    },
    }
    
    func TestUser_printf(t *testing.T) {
        
    	fmt.Printf("%v\n%+v\n%#+v\n", example, example, example)
    }

输出：

[0x1230b00 0x1230bc0]
    [0x1230b00 0x1230bc0]
    []*demo.User{
        (*demo.User)(0x1230b00), (*demo.User)(0x1230bc0)}

这简直啥都没说嘛。。

于是我们可以简单粗暴的解决这个问题。

## Render ##

我们可以通过专门的打印函数实现来完成格式化打印，比如"github.com/luci/go-render/render"

package demo
    
    import (
    	"fmt"
    	"github.com/luci/go-render/render"
    	"testing"
    	"time"
    )
    
    var example = []*User{
        {
        
    	Name:         "string",
    	Age:          26,
    	Gender:       Male,
    	Address:      "this is my home street",
    	BirthDate:    time.Now().UTC(),
    	Introduction: "I'm a happy boy. I like playing guitar.",
    	Fellow: &User{
        
    		Name:         "son",
    		Age:          1,
    		Gender:       Male,
    		Address:      "same with string",
    		BirthDate:    time.Now().Add(-5 * time.Second),
    		Introduction: "son of string",
    	},
    }, {
        
    	Name:         "lemon",
    	Age:          27,
    	Gender:       Male,
    	Address:      "this is my girl",
    	BirthDate:    time.Now().UTC(),
    	Introduction: "I'm a happy girl. I gogogo me.",
    },
    }
    
    func TestUser_printf(t *testing.T) {
        
    	fmt.Printf("%v\n", render.Render(example))
    }

输出：

[]*demo.User{
        (*demo.User){
        Name:"string", Age:26, Gender:demo.Gender(0), Address:"this is my home street", BirthDate:time.Time{
        wall:176993000, ext:63768013141, loc:(*time.Location)(nil)}, Introduction:"I'm a happy boy. I like playing guitar.", Fellow:(*demo.User){
        Name:"son", Age:1, Gender:demo.Gender(0), Address:"same with string", BirthDate:time.Time{
        wall:13856250540789117672, ext:-4999739925, loc:(*time.Location){
        name:"", zone:[]time.zone(nil), tx:[]time.zoneTrans(nil), extend:"", cacheStart:0, cacheEnd:0, cacheZone:(*time.zone)(nil)}}, Introduction:"son of string", Fellow:(*demo.User)(nil)}}, (*demo.User){
        Name:"lemon", Age:27, Gender:demo.Gender(0), Address:"this is my girl", BirthDate:time.Time{
        wall:176995000, ext:63768013141, loc:(*time.Location)(nil)}, Introduction:"I'm a happy girl. I gogogo me.", Fellow:(*demo.User)(nil)}}

打的十分的全面，所有细节都打出来了，数组也没问题。

但还是那回事，太细节了，把time.Time内部结构中一堆根本不关心的东西都打出来了；另外，那个枚举类型打成了Gender(0)，一般我们希望打印成对应的枚举值，也就是Male或Female。

实际中，在快速的开发中，我经常会使用这个函数来快速地打印结构体，方便调试。事实上，只要结构体内没有time.Time，我也很乐意使用render来打印结构体。

但是这个函数的问题也很多，最大的问题是他内部是使用反射来实现的，性能堪忧。层级越复杂，性能越差。后面我们会简单地对比下性能。

## Stringer接口 ##

更优雅地，我会顺手给我写的结构体或者类实现fmt.Stringer接口。

// Stringer is implemented by any value that has a String method,
    // which defines the ``native'' format for that value.
    // The String method is used to print values passed as an operand
    // to any format that accepts a string or to an unformatted printer
    // such as Print.
    type Stringer interface {
        
    	String() string
    }

原理是：fmt.printf等格式化打印函数会默认先确定类型有没有实现Stringer接口，如果实现了的话就会直接调用String()来获取打印结果，而不是走默认格式化方法。

这样，我就可以轻松的定制我想要的输出。比如我大概会为这个User结构体这样实现Stringer接口：

……
    func (u *User) String() string {
        
    	return fmt.Sprintf("User{Name:%q, Age:%v, Gender:%v, Address:%q, BrithDate:%v, Introduction:%q, Fellow:%v}",
    		u.Name, u.Age, u.Gender, u.Address, u.BirthDate, u.Introduction, u.Fellow)
    }

这样，%v或%+v打印出来的效果就是

输出：

[User{
        Name:"string", Age:26, Gender:0, Address:"this is my home street", BrithDate:2021-09-23 17:20:40.197918 +0000 UTC, Introduction:"I'm a happy boy. I like playing guitar.", Fellow:User{
        Name:"son", Age:1, Gender:0, Address:"same with string", BrithDate:2021-09-24 01:20:35.197918 +0800 CST m=-4.999764012, Introduction:"son of string", Fellow:<nil>}} User{
        Name:"lemon", Age:27, Gender:0, Address:"this is my girl", BrithDate:2021-09-23 17:20:40.197921 +0000 UTC, Introduction:"I'm a happy girl. I gogogo me.", Fellow:<nil>}]

look，我们通过Stringer接口轻松控制了格式，指针也能正常展开进行打印，时间也不会被展开，而是按照默认的格式，我可以把Gender也定义Stringer接口：

type Gender int
    
    func (g Gender) String() string {
        
    	switch g {
        
    	case Male:
    		return "Male"
    	case Female:
    		return "Female"
    	default:
    		return "<UNSET>"
    	}
    }
    
    const (
    	Male Gender = iota
    	Female
    )

这样，刚刚的打印出来就成了：

[User{
        Name:"string", Age:26, Gender:Male, Address:"this is my home street", BrithDate:2021-09-23 17:24:58.271852 +0000 UTC, Introduction:"I'm a happy boy. I like playing guitar.", Fellow:User{
        Name:"son", Age:1, Gender:Male, Address:"same with string", BrithDate:2021-09-24 01:24:53.271852 +0800 CST m=-4.999768948, Introduction:"son of string", Fellow:<nil>}} User{
        Name:"lemon", Age:27, Gender:Male, Address:"this is my girl", BrithDate:2021-09-23 17:24:58.271854 +0000 UTC, Introduction:"I'm a happy girl. I gogogo me.", Fellow:<nil>}]

看，Gender那打印的变成了Male，Female了。简直不要太好用。

这个方法还有个好处，就是定制性太高，你可以不只是打印，可以做些额外的事情，输出额外信息，或者隐藏些信息，比如可以隐藏地址，只输出地址的长度：

func (u *User) String() string {
        
    	return fmt.Sprintf("User{Name:%q, Age:%v, Gender:%v, Address:<hide>len(%v), BrithDate:%v, Introduction:%q, Fellow:%v}", u.Name, u.Age, u.Gender, len(u.Address), u.BirthDate, u.Introduction, u.Fellow)
    }

[User{
        Name:"string", Age:26, Gender:Male, Address:<hide>len(22), BrithDate:2021-09-23 17:37:50.698815 +0000 UTC, Introduction:"I'm a happy boy. I like playing guitar.", Fellow:User{
        Name:"son", Age:1, Gender:Male, Address:<hide>len(16), BrithDate:2021-09-24 01:37:45.698815 +0800 CST m=-4.999650007, Introduction:"son of string", Fellow:<nil>}} User{
        Name:"lemon", Age:27, Gender:Male, Address:<hide>len(15), BrithDate:2021-09-23 17:37:50.698818 +0000 UTC, Introduction:"I'm a happy girl. I gogogo me.", Fellow:<nil>}]

有没很好用？hhh

## 为枚举类型自动生成Stringer接口实现 ##

还有点不爽，还得为枚举类型一个个case写对应的字符串，其实Go给我们提供了自动生成的工具。

我们这样改下：

//go:generate stringer -type=Gender
    type Gender int
    
    const (
    	Male Gender = iota
    	Female
    )

然后在同个目录下：

$ go generate

自动就冒出了个gender\_string.go

// Code generated by "stringer -type=Gender"; DO NOT EDIT.
    
    package demo
    
    import "strconv"
    
    func _() {
        
    	// An "invalid array index" compiler error signifies that the constant values have changed.
    	// Re-run the stringer command to generate them again.
    	var x [1]struct{
        }
    	_ = x[Male-0]
    	_ = x[Female-1]
    }
    
    const _Gender_name = "MaleFemale"
    
    var _Gender_index = [...]uint8{
        0, 4, 10}
    
    func (i Gender) String() string {
        
    	if i < 0 || i >= Gender(len(_Gender_index)-1) {
        
    		return "Gender(" + strconv.FormatInt(int64(i), 10) + ")"
    	}
    	return _Gender_name[_Gender_index[i]:_Gender_index[i+1]]
    }

这样就自动实现了枚举类型的Stringer，我们来测试下：

func TestGender_String(t *testing.T) {
        
    	for i := 0; i < 5; i++ {
        
    		fmt.Println(Gender(i))
    	}
    }

输出：

$ go test -v -run=TestGender_String
    === RUN   TestGender_String
    Male
    Female
    Gender(2)
    Gender(3)
    Gender(4)
    --- PASS: TestGender_String (0.00s)
    PASS
    ok      ……/demo      1.605s

效果比自己写的好对吧。而且自动生成的这个文件也有很多值得学习研究的地方。

## 性能比对 ##

我们看看render和stringer的性能对比，就用上面这个简单的结构体加示例来吧。

func Benchmark_default1(b *testing.B) {
        
    	for i := 0; i < b.N; i++ {
        
    		fmt.Sprintf("%v", example)
    	}
    }
    
    func Benchmark_default2(b *testing.B) {
        
    	for i := 0; i < b.N; i++ {
        
    		fmt.Sprintf("%v", render.Render(example))
    	}
    }

其中一个输出：

$ go test -v -bench=. -run=none
    goos: darwin
    goarch: amd64
    pkg: ……/demo
    Benchmark_default1
    Benchmark_default1-12              68085             16994 ns/op
    Benchmark_default2
    Benchmark_default2-12              31875             36993 ns/op
    PASS
    ok      ……/demo      3.663s

我们可以看到，就是这么简单一个结构体，render的性能能比直接自己实现的简单打印的性能差了一倍以上。因此虽然render很方便，在性能要求高的接口上要慎用。

# 结语 #

本文简单讲了下常用的几种格式化打印方法。包括自带的printf，render函数，用stringer定制打印的内容，以及通过go generate工具自动为枚举类型生成stringer实现。并简单测量了下render的性能。由于只是浅谈，并没有详细展开各个点，其实都有很多细节可以讲，可以以后各个分别讲一章。