Golang处理CSV文件的核心是encoding/csv库，通过Reader和Writer实现读写操作。读取时使用csv.NewReader配合io.Reader逐行读取，避免内存溢出；写入时用csv.NewWriter并调用Flush确保数据写入。对于大型文件，推荐逐行处理以降低内存占用。编码问题可通过golang.org/x/text/encoding和transform.NewReader/Writer转换非UTF-8编码（如GBK）为UTF-8。此外，可自定义Comma、Comment、FieldsPerRecord等字段处理不同分隔符、注释行和不规则格式，提升兼容性。
Golang处理CSV文件，
encoding/csv库是其官方标准库中的一把利器，它提供了一种简洁高效的方式来读写CSV格式数据。这库用起来挺顺手，无论是简单的读取还是复杂的写入，它都能胜任，省去了我们自己解析逗号、引号的麻烦。
解决方案
处理CSV文件，核心就是
encoding/csv库里的
Reader和
Writer。读文件，你需要一个
*csv.Reader实例，它会从一个
io.Reader（比如
*os.File）中读取数据。写文件则用
*csv.Writer，它会写入到一个
io.Writer。
来看个简单的读写例子，这基本上是日常工作中会用到的基础模式：
package main
import (
"encoding/csv"
"fmt"
"io"
"log"
"os"
"strings"
)
func main() {
// 示例：写入CSV文件
dataToWrite := [][]string{
{"姓名", "年龄", "城市"},
{"张三", "30", "北京"},
{"李四", "25", "上海"},
{"王五", "35", "广州"},
}
// 创建一个内存中的缓冲区来模拟文件写入，实际应用中会是 os.Create("output.csv")
var b strings.Builder
writer := csv.NewWriter(&b)
for _, record := range dataToWrite {
if err := writer.Write(record); err != nil {
log.Fatalf("写入CSV记录失败: %v", err)
}
}
writer.Flush() // 确保所有缓冲数据都已写入
if err := writer.Error(); err != nil {
log.Fatalf("刷新CSV写入器时出错: %v", err)
}
fmt.Println("写入的CSV内容：")
fmt.Println(b.String())
// 示例：读取CSV文件
// 模拟从字符串读取，实际应用中会是 os.Open("input.csv")
csvContent := `姓名,年龄,城市
张三,30,北京
李四,25,上海
赵六,28,"深圳,福田"` // 注意这里有一个带逗号的字段
reader := csv.NewReader(strings.NewReader(csvContent))
// 如果CSV文件没有固定列数，可以设置FieldsPerRecord为-1
// reader.FieldsPerRecord = -1
fmt.Println("\n读取的CSV内容：")
for {
record, err := reader.Read()
if err == io.EOF {
break // 文件读取完毕
}
if err != nil {
log.Fatalf("读取CSV记录失败: %v", err)
}
fmt.Println(record)
}
}这段代码展示了如何构造
Writer和
Reader，以及最基本的
Write和
Read操作。
Flush对于
Writer来说是关键一步，它能确保所有数据都真正被写入底层
io.Writer。而
io.EOF则是
Read方法返回的信号，告诉你文件已经读到头了。
立即学习“go语言免费学习笔记（深入）”；
Golang如何高效处理大型CSV文件，避免内存溢出？
处理大型CSV文件，最怕的就是内存爆炸。
encoding/csv库其实已经考虑到了这一点，它默认的
Read方法就是逐行读取的，这本身就是一种流式处理。但很多人可能习惯性地去用
reader.ReadAll()，这方法确实方便，一行代码就能把所有数据读到一个
[][]string切片里。问题是，如果文件有几百万行，或者每行数据量都很大，那这个切片瞬间就能撑爆你的内存。
我的建议是，永远优先考虑逐行读取。哪怕你最终需要处理所有数据，也可以考虑分批处理或者边读边处理。
package main
import (
"encoding/csv"
"fmt"
"io"
"log"
"os"
)
func main() {
// 假设我们有一个很大的CSV文件 "large_data.csv"
// 这里用一个字符串模拟大文件内容，实际会是 os.Open("large_data.csv")
largeCSVContent := `id,name,value
1,item_A,100
2,item_B,200
3,item_C,300
` // 想象这里有百万行...
// 创建一个临时的文件来模拟，实际工作中直接打开文件即可
tmpFile, err := os.CreateTemp("", "large_csv_*.csv")
if err != nil {
log.Fatalf("创建临时文件失败: %v", err)
}
defer os.Remove(tmpFile.Name()) // 用完就删
defer tmpFile.Close()
if _, err := tmpFile.WriteString(largeCSVContent); err != nil {
log.Fatalf("写入临时文件失败: %v", err)
}
tmpFile.Seek(0, io.SeekStart) // 重置文件指针到开头
reader := csv.NewReader(tmpFile) // 从文件读取
lineCount := 0
for {
record, err := reader.Read()
if err == io.EOF {
break
}
if err != nil {
log.Printf("读取CSV记录失败 (行 %d): %v", lineCount+1, err)
continue // 遇到错误跳过当前行，或者选择 log.Fatal
}
// 这里是处理每一行数据的地方
// 比如，你可以把数据存入数据库，或者进行增量计算
// fmt.Printf("处理行 %d: %v\n", lineCount+1, record) // 实际处理时可能不会打印，太慢
lineCount++
// 假设我们每处理10000行就打印一次进度
if lineCount%10000 == 0 {
fmt.Printf("已处理 %d 行...\n", lineCount)
}
}
fmt.Printf("CSV文件处理完毕，总计处理 %d 行。\n", lineCount)
}这种逐行读取的方式，内存占用会非常稳定，因为它每次只加载一行数据到内存。即便文件有几十GB，只要你的处理逻辑是线性的，它都能跑得动。这是处理大数据集时最稳妥的策略。
处理CSV文件时常见的编码问题与解决方案是什么？
CSV文件最让人头疼的，除了格式不规范，就是编码问题了。很多时候，文件从Excel或者其他系统导出，默认编码可能不是UTF-8。比如，国内常见的GBK、GB18030，或者某些系统会导出为Latin-1、Shift-JIS等等。当
encoding/csv默认以UTF-8去解析这些非UTF-8编码的文件时，你就会看到一堆乱码，或者直接报错。
Golang标准库本身对非UTF-8编码的支持不是直接内置在
encoding/csv里的，你需要借助
golang.org/x/text/encoding这个扩展库。这个库提供了各种编码器和解码器，可以方便地将非UTF-8字节流转换为UTF-8，反之亦然。
解决方案通常是这样的：
- 识别编码： 如果能提前知道CSV文件的编码，那是最好的。
-
创建解码器： 使用
encoding.NewDecoder()
根据识别到的编码创建一个解码器。 -
包装
io.Reader
： 将原始的os.File
（或其他io.Reader
）用解码器包装起来，形成一个新的io.Reader
。 -
传给
csv.NewReader
： 把这个包装后的io.Reader
传给csv.NewReader
。
package main
import (
"encoding/csv"
"fmt"
"io"
"log"
"os"
"strings"
"golang.org/x/text/encoding/simplifiedchinese" // 导入GBK编码包
"golang.org/x/text/transform" // 导入转换器
)
func main() {
// 模拟一个GBK编码的CSV内容
// "姓名,地址" GBK编码是 []byte{0xd0, 0xc5, 0xc3, 0xf1, 0x2c, 0xb5, 0xd8, 0xd6, 0xb7}
// "张三,北京" GBK编码是 []byte{0xd5, 0xc5, 0xc8, 0xfd, 0x2c, 0xb1, 0xbf, 0xbe, 0xa9}
gbkContent := "\xd0\xc5\xc3\xf1,\xb5\xd8\xd6\xb7\n\xd5\xc5\xc8\xfd,\xb1\xbf\xbe\xa9\n"
// 1. 创建一个GBK解码器
gbkDecoder := simplifiedchinese.GBK.NewDecoder()
// 2. 将GBK编码的字符串内容转换为io.Reader
// 3. 用解码器包装这个io.Reader，使其在读取时自动转换为UTF-8
reader := csv.NewReader(transform.NewReader(strings.NewReader(gbkContent), gbkDecoder))
fmt.Println("读取GBK编码的CSV内容 (已转换为UTF-8):")
for {
record, err := reader.Read()
if err == io.EOF {
break
}
if err != nil {
log.Fatalf("读取CSV记录失败: %v", err)
}
fmt.Println(record)
}
// 写入GBK编码的CSV文件
// 有时候也需要将UTF-8字符串写入为GBK编码的文件
// 比如，某些老旧系统只认GBK
fmt.Println("\n将UTF-8内容写入为GBK编码的CSV:")
dataToEncode := [][]string{
{"商品", "价格"},
{"鼠标", "120"},
{"键盘", "350"},
}
gbkEncoder := simplifiedchinese.GBK.NewEncoder()
var outputBuffer strings.Builder
// transform.NewWriter 会将写入的数据通过 encoder 转换为目标编码
writer := csv.NewWriter(transform.NewWriter(&outputBuffer, gbkEncoder))
for _, record := range dataToEncode {
if err := writer.Write(record); err != nil {
log.Fatalf("写入GBK编码CSV记录失败: %v", err)
}
}
writer.Flush()
if err := writer.Error(); err != nil {
log.Fatalf("刷新GBK编码CSV写入器时出错: %v", err)
}
// 打印GBK编码的字节表示
fmt.Printf("GBK编码的原始字节: %x\n", []byte(outputBuffer.String()))
// 如果想验证，可以再用GBK解码器解码回来打印
decodedBytes, _, _ := transform.Bytes(gbkDecoder, []byte(outputBuffer.String()))
fmt.Printf("解码回来的UTF-8内容: %s\n", decodedBytes)
}这个
transform.NewReader和
transform.NewWriter是解决编码问题的关键。它们就像一个管道，在你读写数据的时候，悄悄地帮你完成了编码转换。这意味着你的
csv.Reader和
csv.Writer始终在处理UTF-8数据，而不用关心底层文件的实际编码，这让代码清晰了很多。
Golang中如何定制CSV分隔符、注释和字段引用符？
encoding/csv库的灵活性体现在它允许你自定义很多解析和写入的规则。CSV文件并不总是用逗号分隔，有时可能是分号、制表符，甚至其他奇奇怪怪的字符。还有些CSV文件会有注释行，或者字段内容本身包含分隔符，需要用引号包起来。这些，
encoding/csv都能处理。
csv.Reader和
csv.Writer都提供了一些公共字段供你配置：
-
Comma
(rune): 设置字段分隔符。默认是逗号','
。 -
Comment
(rune): 设置注释行的起始字符。如果一行以这个字符开头，它会被跳过。默认是0
(不处理注释)。 -
FieldsPerRecord
(int): 期望每条记录的字段数量。如果设置为正数，Read
方法会检查每行字段数是否匹配，不匹配则返回ErrFieldCount
。设置为-1
则表示不检查，每行可以有不同的字段数。默认是0
(第一行确定字段数，后续行必须匹配)。 -
LazyQuotes
(bool): 如果设置为true
，即使字段没有被引号包围，也能容忍字段中出现双引号。这在处理一些不规范的CSV文件时很有用。默认是false
。 -
TrailingComma
(bool): 如果设置为true
，允许行末尾有多余的逗号（即空字段）。默认是false
。
对于
csv.Writer：
-
Comma
(rune): 和Reader
一样，设置写入时的字段分隔符。 -
UseCRLF
(bool): 如果设置为true
，行结束符将使用\r\n
(Windows风格)，否则使用\n
(Unix风格)。默认是true
。 -
QuoteChar
(rune): 字段引用符，当字段内容包含分隔符或换行符时，该字段会被这个字符包围。默认是双引号'"'
。
package main
import (
"encoding/csv"
"fmt"
"io"
"log"
"strings"
)
func main() {
// 示例：自定义Reader的配置
customCSVContent := `# 这是一个注释行
ID;名称;描述
101;产品A;"这是一个包含;分号;的描述"
102;产品B;正常描述
`
reader := csv.NewReader(strings.NewReader(customCSVContent))
reader.Comma = ';' // 设置分隔符为分号
reader.Comment = '#' // 设置注释字符为'#'
reader.FieldsPerRecord = -1 // 不检查字段数量，允许每行字段数不同
reader.LazyQuotes = true // 允许不规范的引号使用
fmt.Println("读取自定义配置的CSV内容:")
for {
record, err := reader.Read()
if err == io.EOF {
break
}
if err != nil {
log.Fatalf("读取自定义CSV记录失败: %v", err)
}
fmt.Println(record)
}
// 示例：自定义Writer的配置
dataToWrite := [][]string{
{"ID", "名称", "描述"},
{"201", "服务X", "提供全面的;技术支持"}, // 描述中包含分号
{"202", "服务Y", "简单描述"},
}
var b strings.Builder
writer := csv.NewWriter(&b)
writer.Comma = ';' // 写入时也使用分号作为分隔符
writer.UseCRLF = false // 使用LF作为行结束符 (Unix风格)
writer.QuoteChar = '\'' // 使用单引号作为引用符
fmt.Println("\n写入自定义配置的CSV内容:")
for _, record := range dataToWrite {
if err := writer.Write(record); err != nil {
log.Fatalf("写入自定义CSV记录失败: %v", err)
}
}
writer.Flush()
if err := writer.Error(); err != nil {
log.Fatalf("刷新自定义CSV写入器时出错: %v", err)
}
fmt.Println(b.String())
}这些配置项给了我们很大的灵活性，去适配各种“奇形怪状”的CSV文件。实际项目中，你可能需要根据具体的文件格式，灵活调整这些参数，才能确保数据的正确解析和生成。我个人觉得
LazyQuotes和
FieldsPerRecord = -1这两个在处理外部来源的CSV时特别有用，因为你永远不知道别人会给你一个多么“野”的文件。
