golang 结构体数组 直接转换为excel

已于 2023-05-25 18:07:20 修改
阅读量827 收藏
点赞数
分类专栏： go excel 结构体映射 文章标签： golang 后端
于 2023-05-25 18:06:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43914306/article/details/130872372
版权
go 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
excel
1 篇文章 0 订阅
订阅专栏
结构体映射
1 篇文章 0 订阅
订阅专栏

golang 结构体 数组 转excel

excel处理，有2种生成方式。遍历对象数组，然后对指定的字段写入到excel格子种。或者流处理，一列一列处理。整体都有个结构体与行的映射过程。

映射方法

可以使用反射做映射，但是代码编写较为麻烦。而且存在较大的性能损耗。直接对结构体转map，进行map遍历。这样就避免了反射操作

ExcelProcess

普通的excel生成方式，性能较慢

ExcelProcessStream

使用流生成excel。性能高

遍历结构体的原理

结构体 json序列化后，转入到map中，对map数组镜像遍历，通过设定Columns指定输出的列顺序，golang的map是无序的。同时也可以跳过不必要的字段。
如果tag标签制定了字段名。需要用对应的tag操作

链式思想改造生成Excel的流程

利用链式思想，只要使用了对应方法，就会设置相应的参数。减少代码if else的判断，优化代码可读性。通过Error链式处理，类似gorm处理过程。避免了大量err 判断

整体代码如下


import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/spf13/cast"
	"github.com/xuri/excelize/v2"
	"io"
	"log"
	"reflect"
)

type ProcessCmd struct {
	headers          []string
	columns          []string
	data             []map[string]interface{}
	DefaultSheetName string
	Path             string
	Error            error
	style            []func(currentSheet string, f *excelize.File) error
}

func ExcelProcess(val interface{}) (p *ProcessCmd) {
	p = &ProcessCmd{DefaultSheetName: "sheet1"}
	if reflect.TypeOf(val).Kind() != reflect.Slice {
		p.Error = fmt.Errorf("val is not slice")
		return p
	}
	arrBytes, err := json.Marshal(val)
	if err != nil {
		p.Error = err
		return
	}
	var data = make([]map[string]interface{}, 0)
	err = json.Unmarshal(arrBytes, &data)
	if err != nil {
		p.Error = err
		return
	}
	p.data = data
	return p
}

func (p *ProcessCmd) Sheet(sheet string) *ProcessCmd {
	if p.Error != nil {
		return p
	}
	p.DefaultSheetName = sheet
	if sheet == "" {
		p.Error = fmt.Errorf("sheet name is empty")
		return p
	}
	return p
}
func (p *ProcessCmd) Style(f func(currentSheet string, f *excelize.File) error) *ProcessCmd {
	if p.Error != nil {
		return p
	}
	p.style = append(p.style, f)

	return p
}

func (p *ProcessCmd) SavePath(path string) *ProcessCmd {
	if p.Error != nil {
		return p
	}
	if path == "" {
		p.Error = fmt.Errorf("path name is empty")
		return p
	}
	p.Path = path
	return p
}
func (p *ProcessCmd) Headers(headers ...string) *ProcessCmd {
	if p.Error != nil {
		return p
	}
	if len(headers) == 0 {
		p.Error = fmt.Errorf("headers  is empty")
		return p
	}
	p.headers = headers
	return p
}
func (p *ProcessCmd) Columns(columns ...string) *ProcessCmd {
	if p.Error != nil {
		return p
	}
	if len(columns) == 0 {
		p.Error = fmt.Errorf("columns  is empty")
		return p
	}
	p.columns = columns
	return p
}

func (p *ProcessCmd) ToExcel() *ProcessCmd {
	if p.Error != nil {
		return p
	}
	f := excelize.NewFile()
	index := f.NewSheet(p.DefaultSheetName)
	f.SetActiveSheet(index)
	rowNumber := 1

	for i := range p.headers {
		colName, err := excelize.ColumnNumberToName(i + 1)
		if err != nil {
			p.Error = err
			return p
		}

		err = f.SetCellValue(p.DefaultSheetName, colName+cast.ToString(rowNumber), p.headers[i])
		if err != nil {
			p.Error = err
			return p
		}

	}

	rowNumber++
	for k := range p.data {
		columnNumber := 1
		if len(p.columns) == 0 {

			for j := range p.data[k] {

				colName, err := excelize.ColumnNumberToName(columnNumber)
				if err != nil {
					p.Error = err
					return p
				}

				err = f.SetCellValue(p.DefaultSheetName, colName+cast.ToString(rowNumber), p.data[k][j])
				if err != nil {
					p.Error = err
					return p
				}
				columnNumber++
			}
		} else {
			for j := range p.columns {
				colName, err := excelize.ColumnNumberToName(columnNumber)
				if err != nil {
					p.Error = err
					return p
				}

				err = f.SetCellValue(p.DefaultSheetName, colName+cast.ToString(rowNumber), p.data[k][p.columns[j]])
				if err != nil {
					p.Error = err
					return p
				}
				columnNumber++
			}
		}

		rowNumber++
	}
	for i := range p.style {
		if p.style[i] != nil {
			err := p.style[i](p.DefaultSheetName, f)
			if err != nil {
				p.Error = err
				return p
			}
		}
	}
	if f.Path == "" {
		p.Path = "demo.xlsx"
	}
	err := f.SaveAs(p.Path)
	if err != nil {
		fmt.Println(err)
	}
	return p
}

type ProcessCmdStream struct {
	headers          []string
	columns          []string
	data             []map[string]interface{}
	DefaultSheetName string
	Path             string
	Error            error
	styleFunc        func(styleMap map[string]int, x int, y int, val interface{}) (int, error)
	newStyleMap      map[string]int
	newStyleFunc     []KeyStyle
	colWidth         []*ColWidth
	writer           io.Writer
}
type ColWidth struct {
	mix   int
	max   int
	width float64
}

func ExcelProcessStream(val interface{}) (p *ProcessCmdStream) {
	p = &ProcessCmdStream{DefaultSheetName: "sheet1", newStyleMap: make(map[string]int, 4)}
	if reflect.TypeOf(val).Kind() != reflect.Slice {
		p.Error = fmt.Errorf("val is not slice")
		return p
	}
	arrBytes, err := json.Marshal(val)
	if err != nil {
		p.Error = err
		return
	}
	var data = make([]map[string]interface{}, 0)
	err = json.Unmarshal(arrBytes, &data)
	if err != nil {
		p.Error = err
		return
	}
	if len(data) == 0 {
		p.Error = errors.New("data is empty")
		return p
	}
	p.data = data
	return p
}
func (p *ProcessCmdStream) SavePath(path string) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	if path == "" {
		p.Error = fmt.Errorf("path name is empty")
		return p
	}
	p.Path = path
	return p
}
func (p *ProcessCmdStream) Headers(header ...string) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}

	p.headers = append(p.headers, header...)
	return p
}
func (p *ProcessCmdStream) Columns(columns ...string) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	if len(columns) == 0 {
		p.Error = fmt.Errorf("columns  is empty")
		return p
	}
	p.columns = columns
	return p
}

func (p *ProcessCmdStream) Sheet(sheet string) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	p.DefaultSheetName = sheet
	if sheet == "" {
		p.Error = fmt.Errorf("sheet name is empty")
		return p
	}
	return p
}
func (p *ProcessCmdStream) Style(styleFunc func(styleMap map[string]int, x int, y int, val interface{}) (int, error)) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	p.styleFunc = styleFunc
	return p
}
func (p *ProcessCmdStream) Writer(writer io.Writer) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	p.writer = writer
	return p
}
func (p *ProcessCmdStream) SetColWidth(min, max int, width float64) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	p.colWidth = append(p.colWidth, &ColWidth{mix: min, max: max, width: width})
	return p
}

type KeyStyle struct {
	Key   string
	Style interface{}
}

func (p *ProcessCmdStream) NewStyle(newStyleFunc ...KeyStyle) *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	p.newStyleFunc = newStyleFunc
	return p
}
func (p *ProcessCmdStream) ToExcel() *ProcessCmdStream {
	if p.Error != nil {
		return p
	}
	f := excelize.NewFile()

	for i := range p.newStyleFunc {
		if p.newStyleFunc != nil {
			styleId, err := f.NewStyle(p.newStyleFunc[i].Style)
			if err != nil {
				p.Error = err
				return p
			}
			p.newStyleMap[p.newStyleFunc[i].Key] = styleId
		}
	}
	stream, err := f.NewStreamWriter(p.DefaultSheetName)
	if err != nil {
		p.Error = err
		return p
	}
	for i := range p.colWidth {
		err = stream.SetColWidth(p.colWidth[i].mix, p.colWidth[i].max, p.colWidth[i].width)
		if err != nil {
			p.Error = err
			return p
		}
	}
	y := 0
	if len(p.headers) > 0 {
		headerRaw := make([]interface{}, 0, len(p.headers))
		for i := range p.headers {
			cell := &excelize.Cell{
				Value: p.headers[i],
			}
			if p.styleFunc != nil {
				styleId, err := p.styleFunc(p.newStyleMap, i, 0, p.headers[i])
				if err != nil {
					p.Error = err
					return p
				}
				cell.StyleID = styleId
			}
			headerRaw = append(headerRaw, cell)
		}
		y++
		err = stream.SetRow("A1", headerRaw)
		if err != nil {
			p.Error = err
			return p
		}
	}

	for k := range p.data {
		x := 0
		var rowValues []interface{}
		if len(p.columns) == 0 {
			rowValues = make([]interface{}, 0, len(p.data[k]))
			for j := range p.data[k] {
				cell := &excelize.Cell{
					Value: p.data[k][j],
				}
				if p.styleFunc != nil {
					styleId, err := p.styleFunc(p.newStyleMap, x, y, p.data[k][j])
					if err != nil {
						p.Error = err
						return p
					}
					cell.StyleID = styleId
				}
				rowValues = append(rowValues, cell)
				x++
			}
		} else {
			rowValues = make([]interface{}, 0, len(p.columns))
			for j := range p.columns {
				cell := &excelize.Cell{
					Value: p.data[k][p.columns[j]],
				}
				if p.styleFunc != nil {
					styleId, err := p.styleFunc(p.newStyleMap, x, y, p.data[k][p.columns[j]])
					if err != nil {
						p.Error = err
						return p
					}
					cell.StyleID = styleId
				}
				rowValues = append(rowValues, cell)
				x++
			}
		}
		cellName, err := excelize.CoordinatesToCellName(1, y+1)
		if err != nil {
			p.Error = err
			return p
		}
		p.Error = stream.SetRow(cellName, rowValues)
		if p.Error != nil {
			return p
		}
		y++
	}
	err = stream.Flush()
	if err != nil {
		p.Error = err
		return p
	}

	if p.writer == nil {
		if p.Path == "" {
			p.Path = "demo.xlsx"
		}

		p.Error = f.SaveAs(p.Path)
		if err != nil {
			return p
		}
		return p
	}
	p.Error = f.Write(p.writer)
	return p
}

type OperationLog struct {
	Id       int
	Username string
	IP       string
	TypeStr  string
	Module   string
	Res      string
	Time     string
	Des      string
}

func main() {
	var list []OperationLog

	list = []OperationLog{
		{1, "xxx", "127.0.0.1", "xx", "xxx", "xxx", "2023-05-06 16:13", "xxx"},
		{2, "xxx", "127.0.0.1", "xx", "xxx", "xxx", "2023-05-06 16:13", "xxx"},
		{3, "xxx", "127.0.0.1", "xx", "xxx", "xxx", "2023-05-06 16:13", "xxx"},
		{4, "xxx", "127.0.0.1", "xx", "xxx", "xxx", "2023-05-06 16:13", "xxx"},
		{5, "xxx", "127.0.0.1", "xx", "xxx", "xxx", "2023-05-06 16:13", "xxx"},
	}

	err := ExcelProcessStream(list).
		Headers("序号", "用户名", "登录IP", "用户类型", "操作模块", "操作结果", "操作时间", "描述").
		Columns("Id", "Username", "IP", "TypeStr", "Module", "Res", "Time", "Des").
		SavePath("demo1.xlsx").SetColWidth(2, 7, 25).SetColWidth(8, 8, 80).
		NewStyle(KeyStyle{
			Key:   "style1",
			Style: &excelize.Style{Font: &excelize.Font{Family: "Microsoft YaHei UI", Size: 12}},
		}, KeyStyle{
			Key: "style2",
			Style: &excelize.Style{Font: &excelize.Font{Family: "Microsoft YaHei UI", Size: 12}, Fill: excelize.Fill{
				Type:    "pattern",
				Pattern: 1,
				Color:   []string{"#E8E8E8"},
			}},
		}).Style(func(styleMap map[string]int, x int, y int, val interface{}) (int, error) {
		if y%2 == 0 {
			return styleMap["style2"], nil
		} else {
			return styleMap["style1"], nil
		}
	}).ToExcel().Error
	if err != nil {
		log.Println("err:", err)
	}
}

生成效果如下

基础生成如下，如果添加Style可以进行自定义处理。样式比较灵活。

ExcelProcessStream(list).
		Headers("序号", "用户名", "登录IP", "用户类型", "操作模块", "操作结果", "操作时间", "描述").
		Columns("Id", "Username", "IP", "TypeStr", "Module", "Res", "Time", "Des").
		SavePath("demo1.xlsx").SetColWidth(2, 7, 25).SetColWidth(8, 8, 80).
		ToExcel().Error

使用工具可以专注于业务的生成
在这里插入图片描述

梦江孙
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
.a文件转换为.lib文件_Excel xls文件批量转换成xlsx文件
weixin_39914752的博客
12-20 341
最近在帮忙做一个教育质量监测工作，需要我对总体抽取样本。总体样本已经收集到，现在已经可以进行抽样，但是收集到的数据文件有两种格式，分别是xlsx和xls文件。为了方便抽样，想把数据格式进行统一，网上找了相关的代码，可以进行批量修改格式。输入下面的代码Sub xls2xlsx()Dim FilePath, MyFile, iPath, Name, OutPath As StringiPat...
golang导出数据为excel文件
m0_51232338的博客
07-31 1234
使用golang实现浏览器导出excel文件功能
导出表结构到Excel 生成代码用
weixin_33949359的博客
01-08 127
  导出表结构到Excel ，统一维护，生成代码用 SELECT C.TABLE_NAME,CC.COMMENTS,C.COLUMN_NAME,C.DATA_TYPE, CASE WHEN C.DATA_TYPE='NUMBER' THEN C.DATA_PRECISION ELSE C.CHAR_LENGTH END AS DATA_LENGTH ,C.DATA_SCALE, C.NUL...
Golang自定义excel导出
最新发布
weixin_37791473的博客
05-10 258
使用 excel 关键字，获取表头。
结构体数组另存为excel_使用EXCEL一键完成拆分表格和另存为独立表
weixin_39989159的博客
12-06 437
第一步，建立宏：点击“开发工具”-“VB”，右键添加两个模块，每个模块代码如下。保存后即可使用。第二步，使用。点击：“开发工具”-“宏”，选择相应模块，点击“执行”。【说明】：一、该宏工具可以单独使用也可以连续使用：顺序1是按照某列字段将一个工作表拆分成多个工作薄，顺序2是将多个工作薄单独另存为独立的工作表，另存过程会在原表路径下新建一个文件夹“临时拆分存放”。二、建好的宏默认只能这一个表中用，如...
go使用excelize导出excel
weixin_45326523的博客
06-05 622
excelize导出excel
golang 将structx写入excel
weixin_41479678的博客
01-20 513
1.func() import( "falcon/middleware/contrib/cache" "fmt" "reflect" "github.com/360EntSecGroup-Skylar/excelize" ) func WriteXlsx(sheet string, records interface{}) *excelize.File { xlsx := excelize.NewFile() // new file index := xlsx.NewSheet(s
Go 结构体、数组、字典和 json 字符串的相互转换方法
09-18
今天小编就为大家分享一篇Go 结构体、数组、字典和 json 字符串的相互转换方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
大家一起学Golang——结构体、方法
01-07
大家一起学Golang——结构体、方法 结构体类型 空结构体 结构体标签 匿名字段 方法 重写 结构体类型 结构体类型通过一系列的且唯一的字段来声明。在go中数组切片只能存储同一类型的数据，但结构体用户可以自定义将...
Golang结构体和map
01-07
Golang 文章目录Golang1 struct2 map3 struct补充 1 struct 在Golang中没有对象,但是有面向对象的思想,有继承,多态,封装的思想。 但是缺少了class,而取而代之的是struct(结构体) 下面的是几种结构体的初始化方法4种...
golang该如何循环 多层结构体
01-20
在Golang中，处理多层结构体循环是一个常见的任务，特别是在数据处理和API开发中。在给定的代码示例中，我们看到了几个结构体类型，包括`Find`、`Article`、`SelectArticle`、`SelectLabel`以及`SiteInfo`。这些...
gova:golang结构体的验证工具
07-04
#gova 它使用结构标记提供验证功能。 ＃＃如何使用？ ...type MyType struct { FirstName string `length:"20" pattern:"[A-Z][a-z]*"` LastName string `length:"20" pattern:"[A-Z][a-z]*"` ...
go之excel操作
weixin_38155824的博客
05-23 1106
package main import ( "fmt" "github.com/xuri/excelize/v2" ) //参考文档：https://www.bookstack.cn/read/excelize-v2.0/spilt.4.1.md func main() { //打开文件 f, err := excelize.OpenFile("./one.xlsx") if err != nil { fmt.Println(err) return } //获取当前工作表索引
Go 生成（读取）xlsx文件
RenXiang_Code的博客
03-07 5746
目录 go 生成xlsx文件 go 读取xlsx文件 1. go生成xlsx文件 github.com/xuri/excelize 下载 go get github.com/xuri/excelize 生成 excel 文件 package main import "github.com/xuri/excelize" import "fmt" func main() { xlsx...
Go语言导出excel文件（.xlsx）
热门推荐
蜗牛先生的博客
09-15 1万+
网上有许多关于导出excel的资料，其中最多的就是创建一个新的.xlsx文件（.xls库不提供写入的功能）。但是这种情况下导出的excel往往比较难看，另一种情况就是打开一个模板，往里面填充东西，往往首行固定。 第一种方法（直接创建） package mainimport ( "github.com/tealeg/xlsx" )func main() { file := xlsx
Golang对excel进行处理
我的天空 我的梦
10-06 1万+
国庆节祝我们的祖国更加繁荣昌盛，想必大家在国庆期间也好好放松了一下，中秋节过节停更了一次，家里面有孩子了，放假期间希望能好好陪陪孩子，请大家谅解。今天发一篇技术文章，帮助大家逐渐回归到正常的工作状态。 之前有关Golang的文章主要是基于Golang的标准库来讲解的，今天我们来看看Golang的一个开源库，它可以用来处理xlsx文件，首先下载包 go get github.com/teale...
Golang Gin导出excel
bingfengjiyi23的博客
01-25 5697
导出用的360的excelize，支持插入图表和图片 Gin框架没有提供方法供浏览器下载，所以这里我们用流 import ( "github.com/360EntSecGroup-Skylar/excelize" "github.com/gin-gonic/gin" ) // 导出 func Export(c *gin.Context) { xlsx := excelize.NewF...
Golang导出并下载excel封装
邓不耙博客
09-03 3009
Gin导出并下载excel封装 这里使用的是: github.com/tealeg/xlsx v3版本没有用过,好像差别挺大的 package main import ( "fmt" "github.com/gin-gonic/gin" "github.com/tealeg/xlsx" "time" ) func main() { //表头 titleList := []string{"ID", "用户", "IP地址", "登陆时间", "说明"} r := gin.Default(
go语言使用echo框架实现将数据导出到excel文件
cmt13579的博客
12-28 2709
准备工作： 首先需要下载需要的对应包 echo框架包：github.com/labstack/echo excel包：github.com/tealeg/xlsx 代码部分： package main import( "bytes" "fmt" "net/http" &am
golang 结构体数组 反转
03-23
在Go语言中，可以使用结构体数组来存储一具有相同结构的数据。要反转一个结构体数组，可以使用双指针的方法进行操作。具体步骤如下： 1. 定义一个结构体类型，例如： ```go type Person struct { Name string Age...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值