你现在为每种固定长度byte数组单独定义类型并实现String()的做法，确实会产生大量重复代码。这里有个更优雅的方案：利用Go的**反射(reflect)**机制，写一个通用的格式化函数，自动把结构体中所有固定长度的byte数组转换成字符串输出，完全不需要修改原结构体的字段类型。

实现思路 #

通过反射遍历传入值的结构：

• 先处理指针类型，确保能获取到结构体的实际值
• 对每个字段，判断其是否是[N]byte类型（固定长度的字节数组）
• 如果是，就将数组转为slice再转换成字符串；否则保持原格式输出

完整代码示例 #

package main

import (
	"fmt"
	"reflect"
)

type FmtA struct {
	Field1 [3]byte
	Field2 [6]byte
	Field3 uint8
}

type FmtB struct {
	Field1 uint16
	Field2 [4]byte
	Field3 [2]byte
}

// CustomPrint 自定义格式化打印，自动处理所有[N]byte类型字段为字符串
func CustomPrint(v interface{}) {
	val := reflect.ValueOf(v)
	// 处理指针类型，先解引用获取实际值
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}
	// 如果不是结构体，直接用默认格式打印
	if val.Kind() != reflect.Struct {
		fmt.Printf("%+v\n", v)
		return
	}

	fmt.Printf("{")
	for i := 0; i < val.NumField(); i++ {
		fieldType := val.Type().Field(i)
		fieldVal := val.Field(i)

		// 打印字段名
		fmt.Printf("%s:", fieldType.Name)

		// 判断是否是固定长度字节数组
		if fieldVal.Kind() == reflect.Array && fieldVal.Type().Elem().Kind() == reflect.Uint8 {
			// 将数组转为slice后转成字符串，用%q保证可读性
			fmt.Printf("%q", fieldVal.Slice(0, fieldVal.Len()).Bytes())
		} else {
			// 其他类型保持默认格式输出
			fmt.Printf("%+v", fieldVal.Interface())
		}

		// 字段间添加分隔空格（最后一个字段不加）
		if i != val.NumField()-1 {
			fmt.Print(" ")
		}
	}
	fmt.Printf("}\n")
}

func main() {
	a := FmtA{[3]byte{'a', 'b', 'c'}, [6]byte{'d', 'e', 'f', 'g', 'h', 'i'}, 36}
	b := FmtB{42, [4]byte{'a', 'b', 'c', 'd'}, [2]byte{'e', 'f'}}
	var i interface{} // 模拟动态接收的变量类型

	fmt.Println("原默认输出：")
	i = a
	fmt.Printf("a=%+v\n", i)
	i = b
	fmt.Printf("b=%+v\n", i)

	fmt.Println("\n自定义格式化输出：")
	i = a
	fmt.Print("a=")
	CustomPrint(i)
	i = b
	fmt.Print("b=")
	CustomPrint(i)
}

输出效果 #

原默认输出：
a={Field1:[97 98 99] Field2:[100 101 102 103 104 105] Field3:36}
b={Field1:42 Field2:[97 98 99 100] Field3:[101 102]}

自定义格式化输出：
a={Field1:"abc" Field2:"defghi" Field3:36}
b={Field1:42 Field2:"abcd" Field3:"ef"}

额外优化：实现fmt.Formatter接口（结构体数量少的场景） #

如果你的结构体数量不多，也可以让每个结构体实现fmt.Formatter接口，这样直接使用fmt.Printf("%+v")就能自动格式化：

func (f FmtA) Format(s fmt.State, verb rune) {
	fmt.Fprintf(s, "{Field1:%q Field2:%q Field3:%d}", string(f.Field1[:]), string(f.Field2[:]), f.Field3)
}

之后调用fmt.Printf("a=%+v\n", a)就会直接输出格式化后的结果。

内容的提问来源于stack exchange，提问作者Daniel YC Lin