这篇文章主要介绍了Go结合反射将结构体转换成Excel的过程详解,大概思路是在Go的结构体中每个属性打上一个excel标签，利用反射获取标签中的内容，作为表格的Header，需要的朋友可以参考下

Excel中的一些概念

编辑

一个excel文件中可以包含多个sheet，一个sheet可以理解成一个表格

表格的每一行称为 Row

表格的每一行中的任意一个单元格称为 Cell

使用tealeg操作Excel

安装tealeg

go get github.com/tealeg/xlsx

使用tealeg新建一个表格

tealeg提供了傻瓜式API，主要流程为创建一个Sheet，在Sheet中添加Row，然后在Row中添加每个单元格的值，最终持久化到磁盘。

func TestTealeg(t *testing.T) {
    excel := xlsx.NewFile()

    // 新建一个sheet
    sheet, err := excel.AddSheet("Sheet1")
    if err != nil {
        t.Fatal(err)
    }
    // 创建首行
    headerRow := sheet.AddRow()

    // 设置行高
    headerRow.SetHeightCM(0.5)

    // 填充行中的单元格
    headerRow.AddCell().Value = "姓名"
    headerRow.AddCell().Value = "年龄"

    valList := [][]string{
        {"张三", "13"},
        {"李四", "14"},
        {"王五", "15"},
    }

    for _, line := range valList {
        row := sheet.AddRow()
        row.SetHeightCM(0.5)
        for _, v := range line {
            row.AddCell().Value = v
        }
    }

    // 持久化到磁盘
    if err := excel.Save("username.xlsx"); err != nil {
        t.Fatal(err)
    }
}

执行这个Test用例后，在项目的当前文件夹中会出现一个username.xlsx的表格，内容和前面介绍的excel概念中使用的表格是一个。 

Go结合反射将结构体转换成Excel

• 大概思路是在Go的结构体中每个属性打上一个excel标签

• 利用反射获取标签中的内容，作为表格的Header

• 利用反射获取Go结构体中的属性的值，组成一个map，key为从标签中excel反射获取的值，val为结构体属性具体的值，map的伪代码如下：map[excelTag]strucVal 类型为map[string]string。

• 如果一个array或者slice中的结构体需要转换成excel，那么只需要将每个元素转换成第 3 步提到的map作为一行，组成一个[]map[excelTag]strucVal然后遍历这个切片，追加到表格中即可。

反射获取每个Struct中的Tag

func getStructTagList(v interface{}, tag string) []string {
    var resList []string
    if v == nil {
        return resList
    }
    var item interface{}
    switch reflect.TypeOf(v).Kind() {
    case reflect.Slice, reflect.Array:
        values := reflect.ValueOf(v)
        if values.Len() == 0 {
            return resList
        }
        item = values.Index(0).Interface()
    case reflect.Struct:
        item = reflect.ValueOf(v).Interface()
    default:
        panic(fmt.Sprintf("type %v not support", reflect.TypeOf(v).Kind()))
    }
    typeOf := reflect.TypeOf(item)
    fieldNum := typeOf.NumField()
    for i := 0; i < fieldNum; i++ {
        resList = append(resList, typeOf.Field(i).Tag.Get(tag))
    }
    return resList
}

通过反射将结构体的值转换成map[excelTag]strucVal 

func getTagValMap(v interface{}, tag string) map[string]string {
    resMap := make(map[string]string)
    if v == nil {
        return resMap
    }
    typeOf := reflect.TypeOf(v)
    fieldNum := typeOf.NumField()
    for i := 0; i < fieldNum; i++ {
        structField := typeOf.Field(i)
        tagValue := structField.Tag.Get(tag)
        val := reflect.ValueOf(v).FieldByName(structField.Name)
        resMap[tagValue] = fmt.Sprintf("%v", val.Interface())
    }
    return resMap
}

利用反射将一个Silce，Array或者Struct转换成[]map[excelTag]strucVal 

func struct2MapTagList(v interface{}, tag string) []map[string]string {
    var resList []map[string]string
    switch reflect.TypeOf(v).Kind() {
    case reflect.Slice, reflect.Array:
        values := reflect.ValueOf(v)
        for i := 0; i < values.Len(); i++ {
            resList = append(resList, getTagValMap(values.Index(i).Interface(), tag))
        }
        break
    case reflect.Struct:
        val := reflect.ValueOf(v).Interface()
        resList = append(resList, getTagValMap(val, tag))
        break
    default:
        panic(fmt.Sprintf("type %v not support", reflect.TypeOf(v).Kind()))
    }
    return resList
}

通过tealeg将[]map[excelTag]strucVal转换成Excel 

通过上面两步，已经可以将一个结构体，切片或者list转换成了一个[]map[excelTag]strucVal类型的切片，下面我们只需要调用tealeg转换成excel

func Struct2Xlsx(v interface{}) (*xlsx.File, error) {
    var tag = "excel"
    tagList := getStructTagList(v, tag)
    mapTagList := struct2MapTagList(v, tag)
    excelFile := xlsx.NewFile()
    sheet, err := excelFile.AddSheet("Sheet1")
    if err != nil {
        return nil, err
    }
    headerRow := sheet.AddRow()
    for _, tagVal := range tagList {
        headerRow.SetHeightCM(0.5)
        headerRow.AddCell().Value = tagVal
    }
    for _, mapTagVal := range mapTagList {
        row := sheet.AddRow()
        for _, tagVal := range tagList {
            row.SetHeightCM(0.5)
            row.AddCell().Value = mapTagVal[tagVal]
        }
    }
    return excelFile, nil
}

运行测试用例验证 

type Username struct {
    Name string `excel:"姓名"`
    Age  int    `excel:"年龄"`
}
func TestStruct2Excet(t *testing.T) {
    var data = []Username{
        {
            Name: "张三",
            Age:  13,
        },
        {
            Name: "李四",
            Age:  14,
        },
        {
            Name: "王五",
            Age:  15,
        },
    }
    excel, err := Struct2Xlsx(data)
    if err != nil {
        t.Fatal(err)
    }
    if err := excel.Save("username.xlsx"); err != nil {
        t.Fatal(err)
    }
}

测试运行成功后，会在项目目录创建一个username.xlsx的文件，这个文件就是我们的结构体转换成excel的结果 

到此这篇关于Go结合反射将结构体转换成Excel的过程详解的文章就介绍到这了