（转）golang 读写文件的四种方式

原文：https://blog.csdn.net/whatday/article/details/103938124

读文件

读取的文件放在file/test：也就是file包下的test这个文件，里面写多一点文件

读文件方式一：利用ioutil.ReadFile直接从文件读取到[]byte中

1.   func Read0() (string){
2.   f, err := ioutil.ReadFile("file/test")
3.   if err != nil {
4.   fmt.Println("read fail", err)
5.   }
6.   return string(f)
7.   }
8.    

读文件方式二：先从文件读取到file中，在从file读取到buf, buf在追加到最终的[]byte

1.   func Read1() (string){
2.   //获得一个file
3.   f, err := os.Open("file/test")
4.   if err != nil {
5.   fmt.Println("read fail")
6.   return ""
7.   }
8.    
9.   //把file读取到缓冲区中
10.   defer f.Close()
11.   var chunk []byte
12.   buf := make([]byte, 1024)
13.    
14.   for {
15.   //从file读取到buf中
16.   n, err := f.Read(buf)
17.   if err != nil && err != io.EOF{
18.   fmt.Println("read buf fail", err)
19.   return ""
20.   }
21.   //说明读取结束
22.   if n == 0 {
23.   break
24.   }
25.   //读取到最终的缓冲区中
26.   chunk = append(chunk, buf[:n]...)
27.   }
28.    
29.   return string(chunk)
30.   //fmt.Println(string(chunk))
31.   }
32.    

读文件方式三：先从文件读取到file, 在从file读取到Reader中，从Reader读取到buf, buf最终追加到[]byte

1.   //先从文件读取到file, 在从file读取到Reader中，从Reader读取到buf, buf最终追加到[]byte，这个排第三
2.   func Read2() (string) {
3.   fi, err := os.Open("file/test")
4.   if err != nil {
5.   panic(err)
6.   }
7.   defer fi.Close()
8.    
9.   r := bufio.NewReader(fi)
10.   var chunks []byte
11.    
12.   buf := make([]byte, 1024)
13.    
14.   for {
15.   n, err := r.Read(buf)
16.   if err != nil && err != io.EOF {
17.   panic(err)
18.   }
19.   if 0 == n {
20.   break
21.   }
22.   //fmt.Println(string(buf))
23.   chunks = append(chunks, buf...)
24.   }
25.   return string(chunks)
26.   //fmt.Println(string(chunks))
27.   }
28.    

读文件方式四：读取到file中，再利用ioutil将file直接读取到[]byte中

1.   //读取到file中，再利用ioutil将file直接读取到[]byte中, 这是最优
2.   func Read3() (string){
3.   f, err := os.Open("file/test")
4.   if err != nil {
5.   fmt.Println("read file fail", err)
6.   return ""
7.   }
8.   defer f.Close()
9.    
10.   fd, err := ioutil.ReadAll(f)
11.   if err != nil {
12.   fmt.Println("read to fd fail", err)
13.   return ""
14.   }
15.    
16.   return string(fd)
17.   }
18.    

读取速度比较

1.   import (
2.   "bufio"
3.   "fmt"
4.   "io"
5.   "io/ioutil"
6.   "os"
7.   "time"
8.   )
9.    
10.   func Read1() string {
11.   f, err := ioutil.ReadFile("/root/test")
12.   if err != nil {
13.   fmt.Println("read fail", err)
14.   }
15.   return string(f)
16.   }
17.    
18.   func Read2() string {
19.   //获得一个file
20.   f, err := os.Open("/root/test")
21.   if err != nil {
22.   fmt.Println("read fail")
23.   return ""
24.   }
25.    
26.   //把file读取到缓冲区中
27.   defer f.Close()
28.   var chunk []byte
29.   buf := make([]byte, 1024)
30.    
31.   for {
32.   //从file读取到buf中
33.   n, err := f.Read(buf)
34.   if err != nil && err != io.EOF {
35.   fmt.Println("read buf fail", err)
36.   return ""
37.   }
38.   //说明读取结束
39.   if n == 0 {
40.   break
41.   }
42.   //读取到最终的缓冲区中
43.   chunk = append(chunk, buf[:n]...)
44.   }
45.    
46.   return string(chunk)
47.   //fmt.Println(string(chunk))
48.   }
49.    
50.   func Read3() string {
51.   fi, err := os.Open("/root/test")
52.   if err != nil {
53.   panic(err)
54.   }
55.   defer fi.Close()
56.    
57.   r := bufio.NewReader(fi)
58.   var chunks []byte
59.    
60.   buf := make([]byte, 1024)
61.    
62.   for {
63.   n, err := r.Read(buf)
64.   if err != nil && err != io.EOF {
65.   panic(err)
66.   }
67.   if 0 == n {
68.   break
69.   }
70.   //fmt.Println(string(buf))
71.   chunks = append(chunks, buf...)
72.   }
73.   return string(chunks)
74.   //fmt.Println(string(chunks))
75.   }
76.    
77.   func Read4() string {
78.   f, err := os.Open("/root/test")
79.   if err != nil {
80.   fmt.Println("read file fail", err)
81.   return ""
82.   }
83.   defer f.Close()
84.    
85.   fd, err := ioutil.ReadAll(f)
86.   if err != nil {
87.   fmt.Println("read to fd fail", err)
88.   return ""
89.   }
90.    
91.   return string(fd)
92.   }
93.    
94.   func main() {
95.   start := time.Now().UnixNano() / 1e6
96.   Read1()
97.   end := time.Now().UnixNano() / 1e6
98.   fmt.Printf("Read1=%d,\n", end-start)
99.   }

分别测试 read2 read3 read4

1.   func main() {
2.   start := time.Now().UnixNano() / 1e6
3.   Read2()
4.   end := time.Now().UnixNano() / 1e6
5.   fmt.Printf("Read2=%d,\n", end-start)
6.   }

1.   func main() {
2.   start := time.Now().UnixNano() / 1e6
3.   Read3()
4.   end := time.Now().UnixNano() / 1e6
5.   fmt.Printf("Read3=%d,\n", end-start)
6.   }

1.   func main() {
2.   start := time.Now().UnixNano() / 1e6
3.   Read4()
4.   end := time.Now().UnixNano() / 1e6
5.   fmt.Printf("Read4=%d,\n", end-start)
6.   }

输出结果

1.   [root@localhost src]# ll -h /root | grep test
2.   -rwxr-xr-x. 1 root root 136M Nov 7 19:20 test
3.   [root@localhost src]# go build
4.   [root@localhost src]# ./test
5.   Read1=625,
6.   [root@localhost src]# go build
7.   [root@localhost src]# ./test
8.   Read2=1313,
9.   [root@localhost src]# go build
10.   [root@localhost src]# ./test
11.   Read3=1724,
12.   [root@localhost src]# go build
13.   [root@localhost src]# ./test
14.   Read4=1057,

经过测试，这四种方式读的速度排名是：前者为优
方式一 > 方式四 > 方式二 > 方式三

写文件

写文件方式一：使用 io.WriteString 写入文件

1.   func Write0() {
2.   fileName := "file/test1"
3.   strTest := "测试测试"
4.    
5.   var f *os.File
6.   var err error
7.    
8.   if CheckFileExist(fileName) { //文件存在
9.   f, err = os.OpenFile(fileName, os.O_APPEND, 0666) //打开文件
10.   if err != nil{
11.   fmt.Println("file open fail", err)
12.   return
13.   }
14.   }else { //文件不存在
15.   f, err = os.Create(fileName) //创建文件
16.   if err != nil {
17.   fmt.Println("file create fail")
18.   return
19.   }
20.   }
21.   //将文件写进去
22.   n, err1 := io.WriteString(f, strTest)
23.   if err1 != nil {
24.   fmt.Println("write error", err1)
25.   return
26.   }
27.   fmt.Println("写入的字节数是：", n)
28.   }
29.    

写文件方式二：使用 ioutil.WriteFile 写入文件

1.   func Write1() {
2.   fileName := "file/test2"
3.   strTest := "测试测试"
4.   var d = []byte(strTest)
5.   err := ioutil.WriteFile(fileName, d, 0666)
6.   if err != nil {
7.   fmt.Println("write fail")
8.   }
9.   fmt.Println("write success")
10.   }
11.    

写文件方式三：使用 File(Write,WriteString) 写入文件

1.   func Write2() {
2.    
3.   fileName := "file/test3"
4.   strTest := "测试测试"
5.   var d1 = []byte(strTest)
6.    
7.   f, err3 := os.Create(fileName) //创建文件
8.   if err3 != nil{
9.   fmt.Println("create file fail")
10.   }
11.   defer f.Close()
12.   n2, err3 := f.Write(d1) //写入文件(字节数组)
13.    
14.   fmt.Printf("写入 %d 个字节n", n2)
15.   n3, err3 := f.WriteString("writesn") //写入文件(字节数组)
16.   fmt.Printf("写入 %d 个字节n", n3)
17.   f.Sync()
18.   }
19.    

写文件方式四：使用 bufio.NewWriter 写入文件

1.   func Write3() {
2.   fileName := "file/test3"
3.   f, err3 := os.Create(fileName) //创建文件
4.   if err3 != nil{
5.   fmt.Println("create file fail")
6.   }
7.   w := bufio.NewWriter(f) //创建新的 Writer 对象
8.   n4, err3 := w.WriteString("bufferedn")
9.   fmt.Printf("写入 %d 个字节n", n4)
10.   w.Flush()
11.   f.Close()
12.   }
13.    

检查文件是否存在：

1.   func CheckFileExist(fileName string) bool {
2.   _, err := os.Stat(fileName)
3.   if os.IsNotExist(err) {
4.   return false
5.   }
6.   return true
7.   }
8.