本文针对 Golang 的结构体字段的打印进行一些研究。其中涉及到一些反射的知识。
问题提出
总结一些实践情况，结构体字段值的输出还是比较常见的，至少笔者目前常用。比如输出某些数据表的数据（代码中会转换为结构体），对比不同版本数据表的数据，对比某些不同版本但格式相同的 json 文件，等。为了优化代码，减少开发维护工作量，需寻找一种高效的方法。打印结构体。需求如下：
- 格式化，目前需迎合 markdown 表格格式。
- 接口可通用于数组、map等结构，原则上直接传递某个变量，即可自行输出格式化后的所需内容。
- 可输出到终端，或文件。
测试数据
本文使用的测试数据如下：
type TestObj struct {
Name string
Value uint64
Size int32
Guard float32
}
var objects []TestObj
object1 := TestObj{
Name: "Jim | Kent",
Value: 128,
Size: 256,
Guard: 56.4,
}
object2 := TestObj{
Name: "James1",
Value: 128,
Size: 259,
Guard: 56.4,
}
objects = append(objects, object1)
objects = append(objects, object2)
var myMap map[string]TestObj
myMap = make(map[string]TestObj)
myMap["obj3"] = TestObj{"Jim Kent", 103, 201, 102.56}
myMap["obj1"] = TestObj{"Kent", 101, 201, 102.56}
myMap["obj2"] = TestObj{"Kent", 102, 201, 102.56}
效果
对于可识别渲染 markdown 的平台来说，输出的如下结果：
print by line - slice default
total: 2
| Name | Value | Size | Guard |
| ------------- | ----- | ---- | ----- |
| Jim <br> Kent | 128 | 256 | 56.4 |
| James1 | 128 | 259 | 56.4 |
就能正常显示表格形式。如下：
print by line - slice default
total: 2
| Name | Value | Size | Guard |
|---|---|---|---|
| Jim Kent | 128 | 256 | 56.4 |
| James1 | 128 | 259 | 56.4 |
简单版本
遍历结构体数据，并打印之：
for a, b := range objects {
fmt.Printf("%v %v\n", a, b)
// fmt.Printf("%v %+v\n", a, b)
}
如果需要格式化，需显式给出结构体字段和格式化形式。如下：
for a, b := range objects {
fmt.Printf("%d: %v | %v | %v | %v\n", a, b.Name, b.Value, b.Size, b.Guard)
}
以上结果分别如下：
0 {Jim | Kent 128 256 56.4}
1 {James1 128 259 56.4}
0: Jim | Kent | 128 | 256 | 56.4
1: James1 | 128 | 259 | 56.4
由于此版本非吾所用，因此只具大致形式。
%v%+v{xx xx xx}|reflect版本
代码如下：
func checkSkipNames(a string, b []string) bool {
for _, item := range b {
if item == a {
return true
}
}
return false
}
// 结构体的字段名称
func GetStructName(myref reflect.Value, names []string) (buffer string) {
// 注：有可能传递string数组，此时没有“标题”一说，返回
if myref.Type().Name() == "string" {
return
}
for i := 0; i < myref.NumField(); i++ {
if ok := checkSkipNames(myref.Type().Field(i).Name, names); ok {
continue
}
buffer += fmt.Sprintf("| %v ", myref.Type().Field(i).Name)
}
buffer += fmt.Sprintf("|\n")
for i := 0; i < myref.NumField(); i++ {
if ok := checkSkipNames(myref.Type().Field(i).Name, names); ok {
continue
}
buffer += fmt.Sprintf("| --- ")
}
buffer += fmt.Sprintf("|\n")
return
}
// 将 | 替换为 <br>
func replaceI(text string) (ret string) {
// 下面2种方法都可以
// reg := regexp.MustCompile(`\|`)
// ret = reg.ReplaceAllString(text, `${1}<br/>`)
ret = strings.Replace(text, "|", "<br>", -1)
// fmt.Printf("!!! %q\n", ret)
return ret
}
// 结构体的值
func GetStructValue(myref reflect.Value, names []string) (buffer string) {
for i := 0; i < myref.NumField(); i++ {
if ok := checkSkipNames(myref.Type().Field(i).Name, names); ok {
continue
}
// 判断是否包含|，有则替换，其必须是string类型，其它保持原有的
t := myref.Field(i).Type().Name()
if t == "string" {
var str string = myref.Field(i).Interface().(string)
str = replaceI(str)
buffer += fmt.Sprintf("| %v ", str)
} else {
buffer += fmt.Sprintf("| %v ", myref.Field(i).Interface())
}
}
buffer += fmt.Sprintf("|\n")
return
}
func PrintStructTable(data interface{}, title string, skipNames ...string) {
var w io.Writer
w = os.Stdout // set to stdout
buffer, num := PrintStructTable2Buffer(data, title, skipNames...)
fmt.Fprintf(w, "total: %v\n", num)
fmt.Fprintf(w, "%v\n", buffer)
}
/*
功能：指定结构体data，其可为slice map 单独结构体
指定自定义标题，为空则使用结构体字段
指定忽略的字段名称（即结构体字段的变量）
按结构体定义的顺序列出，如自定义标题，则必须保证一致。
*/
func PrintStructTable2Buffer(data interface{}, title string, skipNames ...string) (buffer string, num int) {
buffer = ""
t := reflect.TypeOf(data)
v := reflect.ValueOf(data)
var skipNamess []string
for _, item := range skipNames {
skipNamess = append(skipNamess, item)
}
// 打印结构体字段标志
innertitle := false
printHead := false
if len(title) == 0 {
innertitle = true
}
// 不同类型的，其索引方式不同，故一一判断使用
switch t.Kind() {
case reflect.Slice, reflect.Array:
num = v.Len()
if innertitle {
buffer += GetStructName(v.Index(0), skipNamess)
} else {
buffer += fmt.Sprintln(title)
}
for i := 0; i < v.Len(); i++ {
buffer += GetStructValue(v.Index(i), skipNamess)
}
case reflect.Map:
num = v.Len()
iter := v.MapRange()
for iter.Next() {
if !printHead {
if innertitle {
buffer += GetStructName(iter.Value(), skipNamess)
} else {
buffer += fmt.Sprintln(title)
}
printHead = true
}
buffer += GetStructValue(iter.Value(), skipNamess)
}
default:
num = 1 // 单独结构体不能用Len，单独赋值
if !printHead {
if innertitle {
buffer += GetStructName(v, skipNamess)
} else {
buffer += fmt.Sprintln(title)
}
printHead = true
}
buffer += GetStructValue(v, skipNamess)
}
return
}
PrintStructTable2BufferPrintStructTablemarkdownTablePrintStructTable2BuffertitlecheckSkipNamesGetStructNameGetStructValueinterface{}
测试代码如下：
// 数组，默认形式
fmt.Println("print by line - slice default")
buf, num := PrintStructTable2Buffer(objects, "")
fmt.Println("total:", num)
fmt.Println(buf)
// 数组，自定义标题
fmt.Println("print by line - slice")
buf, num = PrintStructTable2Buffer(objects, "| Name | Value | Size | Guard |\n| --- | --- | --- | ++++ |")
fmt.Println("total:", num)
fmt.Println(buf)
// 单个对象
fmt.Println("print by line - single object")
buf, num = PrintStructTable2Buffer(object1, "| Name | Value | Guard |\n| +++ | +++ | +++ |", "Size")
fmt.Println("total:", num)
fmt.Println(buf)
// map
fmt.Println("print by line - map")
buf, num = PrintStructTable2Buffer(myMap, "aaa")
fmt.Println(buf)
测试结果如下：
print by line - slice default
total: 2
| Name | Value | Size | Guard |
| --- | --- | --- | --- |
| Jim <br> Kent | 128 | 256 | 56.4 |
| James1 | 128 | 259 | 56.4 |
print by line - slice
total: 2
| Name | Value | Size | Guard |
| --- | --- | --- | ++++ |
| Jim <br> Kent | 128 | 256 | 56.4 |
| James1 | 128 | 259 | 56.4 |
print by line - single object
total: 1
| Name | Value | Guard |
| +++ | +++ | +++ |
| Jim <br> Kent | 128 | 56.4 |
print by line - map
aaa
| Jim Kent | 103 | 201 | 102.56 |
| Kent | 101 | 201 | 102.56 |
| Kent | 102 | 201 | 102.56 |
观察结果，可达到预期目的。