5-1. go 操作csv

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

//csv文件读取
func ReadCsv(filepath string) {
	//打开文件(只读模式)，创建io.read接口实例
	opencast,err:=os.Open(filepath)
	if err!=nil{
		log.Println("csv文件打开失败！")
	}
	defer opencast.Close()
	
	//创建csv读取接口实例
	ReadCsv:=csv.NewReader(opencast)

	//获取一行内容，一般为第一行内容
	read,_:=ReadCsv.Read() //返回切片类型：[chen  hai wei]
	log.Println(read)

	//读取所有内容
	ReadAll,err:=ReadCsv.ReadAll()//返回切片类型：[[s s ds] [a a a]]
	log.Println(ReadAll)

	/*
	  说明：
	   1、读取csv文件返回的内容为切片类型，可以通过遍历的方式使用或Slicer[0]方式获取具体的值。
	   2、同一个函数或线程内，两次调用Read()方法时，第二次调用时得到的值为每二行数据，依此类推。
	   3、大文件时使用逐行读取，小文件直接读取所有然后遍历，两者应用场景不一样，需要注意。
	*/


}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//csv文件写入
func WriterCSV(path string)  {

	//OpenFile读取文件，不存在时则创建，使用追加模式
	File,err:=os.OpenFile(path,os.O_RDWR|os.O_APPEND|os.O_CREATE,0666)
	if err!=nil{
		log.Println("文件打开失败！")
	}
	defer File.Close()

	//创建写入接口
	WriterCsv:=csv.NewWriter(File)
    str:=[]string{"chen1","hai1","wei1"} //需要写入csv的数据，切片类型

	//写入一条数据，传入数据为切片(追加模式)
	err1:=WriterCsv.Write(str)
	if err1!=nil{
		log.Println("WriterCsv写入文件失败")
	}
	WriterCsv.Flush() //刷新，不刷新是无法写入的
	log.Println("数据写入成功...")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

package main

// 从Mysql中导出数据到CSV文件。

import (
	"database/sql"
	"encoding/csv"
	"fmt"
	"os"

	_ "github.com/go-sql-driver/mysql"
)

var (
	tables = []string{"goods"}
	count  = len(tables)
	ch     = make(chan bool, count)
)

func main() {
	db, err := sql.Open("mysql", "root:Abcd@123456@tcp(127.0.0.1:3306)/mxshop_goods_srv?charset=utf8")
	defer db.Close()
	if err != nil {
		panic(err.Error())
	}

	for _, table := range tables {
		go querySQL(db, table, ch)
	}

	for i := 0; i < count; i++ {
		<-ch
	}
	fmt.Println("Done!")
}

func querySQL(db *sql.DB, table string, ch chan bool) {
	fmt.Println("开始处理：", table)
	rows, _ := db.Query(fmt.Sprintf("SELECT * from %s", table))

	columns, err := rows.Columns()
	if err != nil {
		panic(err.Error())
	}

	//values：一行的所有值，长度==列数
	values := make([]sql.RawBytes, len(columns))

	scanArgs := make([]interface{}, len(values))
	for i := range values {
		scanArgs[i] = &values[i]
	}

	var totalValues [][]string
	for rows.Next() {
		var s []string
		err = rows.Scan(scanArgs...) //把每行的内容添加到scanArgs，也添加到了values
		if err != nil {
			panic(err.Error())
		}

		for _, v := range values {
			s = append(s, string(v))
			fmt.Println(s)
		}
		totalValues = append(totalValues, s)
	}

	if err = rows.Err(); err != nil {
		panic(err.Error())
	}
	writeToCSV(table+".csv", columns, totalValues)
	ch <- true
}

func writeToCSV(file string, columns []string, totalValues [][]string) {
	// fmt.Println(columns)
	f, err := os.Create(file)
	if err != nil {
		panic(err)
	}
	f.WriteString("\xEF\xBB\xBF") //写入UTF-8 格式
	defer f.Close()
	w := csv.NewWriter(f)
	for a, i := range totalValues {
		if a == 0 {
			w.Write(columns)
			w.Write(i)
		} else {
			// fmt.Println(i)
			w.Write(i)
		}
	}
	w.Flush()
	fmt.Println("处理完毕：", file)
}