go-fixedwidth库使用指南

go-fixedwidth是一个用于处理固定宽度文本的Go语言库，它提供了编码(序列化)和解码(反序列化)功能，支持通过结构体标签定义字段位置。

安装

go get github.com/ianlopshire/go-fixedwidth

基本用法

1. 解码固定宽度文本

package main

import (
	"fmt"
	"strings"
	
	"github.com/ianlopshire/go-fixedwidth"
)

type Person struct {
	ID        int     `fixed:"1,5"`
	Name      string  `fixed:"6,15"`
	Age       int     `fixed:"16,18"`
	Salary    float64 `fixed:"19,25"`
	IsActive  bool    `fixed:"26,26"`
}

func main() {
	data := `00123John Doe     301234.561`
	
	var p Person
	err := fixedwidth.Unmarshal([]byte(data), &p)
	if err != nil {
		panic(err)
	}
	
	fmt.Printf("%+v\n", p)
	// 输出: {ID:123 Name:John Doe Age:30 Salary:1234.56 IsActive:true}
}

2. 编码为固定宽度文本

func main() {
	p := Person{
		ID:       456,
		Name:     "Jane Smith",
		Age:      28,
		Salary:   9876.54,
		IsActive: false,
	}
	
	encoded, err := fixedwidth.Marshal(p)
	if err != nil {
		panic(err)
	}
	
	fmt.Println(string(encoded))
	// 输出: 00456Jane Smith  289876.540
}

高级特性

1. 自定义对齐和填充

type Product struct {
	Code      string  `fixed:"1,10,left"`    // 左对齐，右侧填充空格
	Price     float64 `fixed:"11,20,right"`  // 右对齐，左侧填充空格
	Available bool    `fixed:"21,21,center"` // 居中对齐
}

func main() {
	prod := Product{
		Code:      "A123",
		Price:     19.99,
		Available: true,
	}
	
	encoded, _ := fixedwidth.Marshal(prod)
	fmt.Println(string(encoded))
	// 输出: A123         19.99   1
}

2. 嵌套结构体

type Address struct {
	Street string `fixed:"1,20"`
	City   string `fixed:"21,35"`
}

type Customer struct {
	Name    string  `fixed:"1,15"`
	Address Address `fixed:"16,50"`
	Phone   string  `fixed:"51,65"`
}

func main() {
	data := `John Doe      123 Main St    New York      555-1234`
	
	var c Customer
	_ = fixedwidth.Unmarshal([]byte(data), &c)
	
	fmt.Printf("%+v\n", c)
	// 输出: {Name:John Doe Address:{Street:123 Main St City:New York} Phone:555-1234}
}

3. 自定义类型处理

type YesNo bool

func (yn *YesNo) UnmarshalFixed(data []byte) error {
	*yn = string(data) == "Y"
	return nil
}

func (yn YesNo) MarshalFixed() ([]byte, error) {
	if yn {
		return []byte("Y"), nil
	}
	return []byte("N"), nil
}

type Survey struct {
	ID     int  `fixed:"1,5"`
	Agreed YesNo `fixed:"6,6"`
}

func main() {
	data := `00123Y`
	
	var s Survey
	_ = fixedwidth.Unmarshal([]byte(data), &s)
	
	fmt.Printf("%+v\n", s) // 输出: {ID:123 Agreed:true}
	
	s.Agreed = false
	encoded, _ := fixedwidth.Marshal(s)
	fmt.Println(string(encoded)) // 输出: 00123N
}

错误处理

func main() {
	data := `0012XJohn Doe     301234.561` // ID字段应该是数字但包含X
	
	var p Person
	err := fixedwidth.Unmarshal([]byte(data), &p)
	if err != nil {
		fmt.Println("解码错误:", err)
		// 输出: 解码错误: strconv.ParseInt: parsing "0012X": invalid syntax
	}
}

性能考虑

go-fixedwidth使用反射实现，对于高性能场景，可以考虑以下优化：

1. 预编译编码器/解码器
2. 避免在循环中频繁创建临时结构体
3. 对于非常大的文件，考虑流式处理

总结

go-fixedwidth提供了简单而强大的方式来处理固定宽度文本数据，通过结构体标签可以方便地定义字段位置和对齐方式。它特别适合处理传统系统、银行文件、旧式数据交换格式等固定宽度文本场景。

对于更复杂的需求，可以结合自定义类型和编解码方法实现灵活的数据转换。