Golang的文件处理方式-常见的读写

　在 Golang 语言中，文件使用指向 os.File 类型的指针来表示的，也叫做文件句柄。注意，标准输入 os.Stdin 和标准输出 os.Stdout ，他们的类型都是 *os.File 哟。在任何计算机设备中，文件是都是必须的对象，而在 Web编程中,文件的操作一直是 Web程序员经常遇到的问题,文件操作在 Web应用中是必须的,非常有用的,我们经常遇到生成文件目录,文件(夹)编辑等操作。

 

一.文件的读取姿势

  我有一只小毛驴.txt（文件内容戳我）

姿势1.顺序读取文件内容

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "bufio"
12     "fmt"
13     "io"
14     "os"
15 )
16 
17 var (
18     FileName string = "E:\\Code\\Golang\\Golang_Program\\文件处理\\我有一只小毛驴.txt"    //这是我们需要打开的文件，当然你也可以把它定义到从某个配置文件来获取变量。
19     InputFile  *os.File    //变量 InputFile 是 *os.File 类型的。该类型是一个结构，表示一个打开文件的描述符（文件句柄）。
20     InputError error    //我们使用 os 包里的 Open 函数来打开一个文件。如果文件不存在或者程序没有足够的权限打开这个文件，Open函数会返回一个错误，InputError变量就是用来接收这个错误的。
21     Count int            //这个变量是我们用来统计行号的，默认值为0.
22 )
23 
24 func main() {
25     //InputFile,InputError = os.OpenFile(FileName,os.O_CREATE|os.O_RDWR,0644) //打开FileName文件，如果不存在就创建新文件，打开的权限是可读可写，权限是644。这种打开方式相对下面的打开方式权限会更大一些。
26     InputFile, InputError = os.Open(FileName) //使用 os 包里的 Open 函数来打开一个文件。该函数的参数是文件名，类型为 string 。我们以只读模式打开"FileName"文件。
27     if InputError != nil {    //如果打开文件出错，那么我们可以给用户一些提示，然后在推出函数。
28         fmt.Printf("An error occurred on opening the inputfile\n" +
29             "Does the file exist?\n" +
30             "Have you got acces to it?\n")
31         return // exit the function on error
32     }
33     defer InputFile.Close()        //defer关键字是用在程序即将结束时执行的代码,确保在程序退出前关闭该文件。
34     inputReader := bufio.NewReader(InputFile) //我们使用 bufio.NewReader()函数来获得一个读取器变量（读取器）。我们可以很方便的操作相对高层的 string 对象，而避免了去操作比较底层的字节。
35     for {
36         Count += 1
37         inputString, readerError := inputReader.ReadString('\n')  //我们将inputReader里面的字符串按行进行读取。
38         if readerError == io.EOF {
39             return  //如果遇到错误就终止循环。
40         }
41         fmt.Printf("The %d line is: %s",Count, inputString)    //将文件的内容逐行（行结束符'\n'）读取出来。
42     }
43 }
44 
45 
46 
47 #以上代码执行结果如下：
48 The 1 line is: 歌曲：我有一只小毛驴
49 The 2 line is: 歌手：碧瑶
50 The 3 line is: 专辑：《瑶谣摇》
51 The 4 line is: 发行时间：2014-03-18
52 The 5 line is: 词：付林
53 The 6 line is: 曲：付林
54 The 7 line is: 歌词：
55 The 8 line is: 我有一只小毛驴
56 The 9 line is: 我从来也不骑
57 The 10 line is: 有一天我心血来潮骑着去赶集
58 The 11 line is: 我手里拿着小皮鞭
59 The 12 line is: 我心里很得意
60 The 13 line is: 不知怎么哗啦啦啦啦
61 The 14 line is: 摔了一身泥
62 The 15 line is: 我有一只小毛驴
63 The 16 line is: 我从来也不骑
64 The 17 line is: 有一天我心血来潮骑着去赶集
65 The 18 line is: 我手里拿着小皮鞭
66 The 19 line is: 我心里很得意
67 The 20 line is: 不知怎么哗啦啦啦啦
68 The 21 line is: 摔了一身泥
69 The 22 line is: 我有一只小毛驴 我从来也不骑
70 The 23 line is: 有一天我心血来潮 骑着去赶集
71 The 24 line is: 我手里拿着小皮鞭 我心里很得意
72 The 25 line is: 不知怎么哗啦啦啦 摔了一身泥
73 The 26 line is: 我有一只小毛驴 我从来也不骑
74 The 27 line is: 有一天我心血来潮 骑着去赶集
75 The 28 line is: 我手里拿着小皮鞭 我心里很得意
76 The 29 line is: 不知怎么哗啦啦啦 摔了一身泥
77 The 30 line is: 我手里拿着小皮鞭 我心里很得意

 

姿势2.按列读取数据

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "os"
13 )
14 
15 var (
16     FileName = "E:\\Code\\Golang\\Golang_Program\\文件处理\\a.txt"
17 )
18 
19 /*
20 注意：FileName的文件内容如下：
21 A B C
22 a b c
23 1 2 3
24 */
25 
26 func main() {
27     file, err := os.Open(FileName)
28     if err != nil {
29         panic(err)
30     }
31     defer file.Close()
32     var Column1, Column2, Column3 []string    //定义3个切片，每个切片用来保存不同列的数据。
33 
34     for {
35         var FirstRowColumn, SecondRowColumn, ThirdRowColumn string
36         _, err := fmt.Fscanln(file, &FirstRowColumn, &SecondRowColumn, &ThirdRowColumn)    //如果数据是按列排列并用空格分隔的，我们可以使用 fmt 包提供的以 FScan 开头的一系列函数来读取他们。
37         if err != nil {
38             break
39         }
40         Column1 = append(Column1, FirstRowColumn)  //将第一列的每一行的参数追加到空切片Column1中。以下代码类似。
41         Column2 = append(Column2, SecondRowColumn)
42         Column3 = append(Column3, ThirdRowColumn)
43     }
44     fmt.Println(Column1)
45     fmt.Println(Column2)
46     fmt.Println(Column3)
47 }
48 
49 
50 
51 #以上代码执行结果如下：
52 [A a 1]
53 [B b 2]
54 [C c 3]

 

姿势3. 带缓冲的读取

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12     "bufio"
13     "io"
14     "fmt"
15 )
16 
17 var (
18     FileName = "E:\\Code\\Golang\\Golang_Program\\文件处理\\我有一只小毛驴.txt"
19 )
20 
21 func main() {
22     f,err := os.Open(FileName)
23     if err != nil{
24         panic(err)
25     }
26     defer f.Close()
27     ReadSize := make([]byte,1024) //指定每次读取的大小为1024。
28     ReadByte := make([]byte,4096,4096) //指定读取到的字节数。
29     r := bufio.NewReader(f)
30     for   {
31         ActualSize,err := r.Read(ReadSize)    //回返回每次读取到的实际字节大小。
32         if err != nil && err != io.EOF {
33             panic(err)
34         }
35         if ActualSize == 0 {
36             break
37         }
38         ReadByte = append(ReadByte,ReadSize[:ActualSize]...)    //将每次的读取到的内容都追加到我们定义的切片中。
39     }
40     fmt.Println(string(ReadByte))    //打印我们读取到的内容，注意，不能直接读取，因为我们的切片的类型是字节，需要转换成字符串这样我们读取起来会更方便。
41 }

 

姿势4.将整个文件的内容读到一个字节切片中

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "io/ioutil"
13     "os"
14     "reflect"
15 )
16 
17 var (
18     FileName = "E:\\Code\\Golang\\Golang_Program\\文件处理\\我有一只小毛驴.txt"
19 )
20 
21 func main() {
22     buf, err := ioutil.ReadFile(FileName) //将整个文件的内容读到一个字节切片中。
23     fmt.Println(reflect.TypeOf(buf))
24     if err != nil {
25         fmt.Fprintf(os.Stderr, "File Error: %s\n", err)
26         // panic(err.Error())
27     }
28     fmt.Printf("%s\n", string(buf))
29 }
30 
31 
32 
33 #以上代码执行结果如下：
34 []uint8
35 歌曲：我有一只小毛驴
36 歌手：碧瑶
37 专辑：《瑶谣摇》
38 发行时间：2014-03-18
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 不知怎么哗啦啦啦 摔了一身泥

 

 

二.文件的写入姿势

 姿势1：打开一个文件，如果没有就创建，如果有这个文件就清空文件内容（相当于python中的"w"）

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12     "log"
13 )
14 
15 
16 
17 func main()  {
18     f,err := os.Create("a.txt") //姿势一：打开一个文件，如果没有就创建，如果有这个文件就清空文件内容,需要用两个变量接受相应的参数
19     if err != nil {
20         log.Fatal(err)
21     }
22     f.WriteString("yinzhengjie\n") //往文件写入相应的字符串。
23     f.Close()
24 }

姿势2：以追加的方式打开一个文件（相当于python中的"a"）

　　OpenFile 函数有三个参数：文件名、一个或多个标志（使用逻辑运算符“|”连接），使用的文件权限。我们通常会用到以下标志：

　　　　1>.os.O_RDONLY ：只读

　　　　2>.os.WRONLY ：只写

　　　　3>.os.O_CREATE ：创建：如果指定文件不存在，就创建该文件。

　　　　4>.os.O_TRUNC ：截断：如果指定文件已存在，就将该文件的长度截为0。

　　在读文件的时候，文件的权限是被忽略的，所以在使用 OpenFile 时传入的第三个参数可以用0。

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12     "log"
13 )
14 
15 
16 func main()  {
17     f,err := os.OpenFile("a.txt",os.O_APPEND|os.O_CREATE|os.O_RDWR,0644) //表示最佳的方式打开文件，如果不存在就创建，打开的模式是可读可写，权限是644
18     if err    != nil {
19         log.Fatal(err)
20     }
21     f.WriteString("yinzhengjie\n")
22     f.Close()
23 }

姿势3：修改文件内容-随机写入（自定义插入的位置，相当python重的seek方法）

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12     "log"
13 )
14 
15 
16 func main()  {
17     f,err := os.OpenFile("a.txt",os.O_CREATE|os.O_RDWR,0644)
18     if err != nil {
19         log.Fatal(err)
20     }
21     f.WriteString("yinzhengjie\n")
22     f.Seek(1,os.SEEK_SET) //表示文件的其实位置，从第二个字符往后写入。
23     f.WriteString("$$$")
24     f.Close()
25 }

姿势4.ioutil方法创建文件

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "io/ioutil"
13     "os"
14 )
15 
16 var (
17     FileName = "E:\\Code\\Golang\\Golang_Program\\文件处理\\我有一只小毛驴.txt"
18     OutputFile = "E:\\Code\\Golang\\Golang_Program\\文件处理\\复制的小毛驴.txt"
19 )
20 
21 func main() {
22     buf, err := ioutil.ReadFile(FileName) //将整个文件的内容读到一个切片中。
23     if err != nil {
24         fmt.Fprintf(os.Stderr, "File Error: %s\n", err)
25         // panic(err.Error())
26     }
27     //fmt.Printf("%s\n", string(buf))
28     err = ioutil.WriteFile(OutputFile, buf, 0x644)    //我们将读取到的内容又重新写入到另外一个OutputFile文件中去。
29     if err != nil {
30         panic(err. Error())
31     }
32     
33     /*注意，在执行该代码之后，就会生成一个OutputFile文件，其内容和FileName的内容是一致的哟！*/
34 }

 

三.文件的删除操作

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import "os"
11 
12 var (
13     FileName = "E:\\Code\\Golang\\Golang_Program\\文件处理\\复制的小毛驴.txt"
14 )
15 
16 func main() {
17     os.Remove(FileName)    //删除文件比较方便，直接用OS包就搞定啦的Remove方法就搞定案啦！
18 }

 

四.目录的操作姿势

1.目录的创建操作

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "os"
12 )
13 
14 var (
15     OneLevelDirectory = "yinzhengjie"
16     MultilevelDirectory = "yinzhengjie/golang/code"
17 )
18 func main() {
19     os.Mkdir(OneLevelDirectory, 0777)    //创建名称为OneLevelDirectory的目录，设置权限为0777。相当于Linux系统中的“mkdir yinzhengjie”
20     os.MkdirAll(MultilevelDirectory, 0777)    //创建MultilevelDirectory多级子目录，设置权限为0777。相当于Linux中的 “mkdir -p yinzhengjie/golang/code”
21 }

 

2.目录的删除操作

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "os"
13 )
14 
15 var (
16     OneLevelDirectory = "yinzhengjie"
17     MultilevelDirectory = "yinzhengjie/golang/code"
18 )
19 
20 func main() {
21     err := os.Remove(MultilevelDirectory) //删除名称为OneLevelDirectory的目录，当目录下有文件或者其他目录是会出错。
22     if err != nil {
23         fmt.Println(err)
24     }
25     os.RemoveAll(OneLevelDirectory) //根据path删除多级子目录，如果 path是单个名称，那么该目录不删除。
26 }

 

五.文件处理进阶知识

 1.读取压缩文件

　　compress 包提供了读取压缩文件的功能，支持的压缩文件格式为：bzip2、flate、gzip、lzw 和 zlib。下面的程序展示了如何读取一个 gzip 文件。

 1 [root@yinzhengjie code]# ll
 2 总用量 16
 3 -rw-r--r--+ 1 root root 891 11月  8 13:55 littleDonkey
 4 -rw-r--r--+ 1 root root 734 11月  8 13:57 readFile.go
 5 [root@yinzhengjie code]# more littleDonkey 
 6 歌曲：我有一只小毛驴
 7 歌手：碧瑶
 8 专辑：《瑶谣摇》
 9 发行时间：2014-03-18
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 [root@yinzhengjie code]# tar zcf littleDonkey.tar.gz littleDonkey     #创建压缩文件
38 [root@yinzhengjie code]# go run readFile.go littleDonkey.tar.gz 
39 littleDonkey0000644000000000000000000000157313200516146012152 0ustar  rootroot歌曲：我有一只小毛驴
40 歌手：碧瑶
41 专辑：《瑶谣摇》
42 发行时间：2014-03-18
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 Done reading file
71 [root@yinzhengjie code]#
72 [root@yinzhengjie code]# pwd
73 /yinzhengjie/golang/code
74 [root@yinzhengjie code]# ll
75 总用量 24
76 -rw-r--r--+ 1 root root 891 11月  8 13:55 littleDonkey
77 -rw-r--r--+ 1 root root 385 11月  8 13:58 littleDonkey.tar.gz
78 -rw-r--r--+ 1 root root 734 11月  8 13:57 readFile.go
79 [root@yinzhengjie code]# 

 2.文件拷贝

　　我们在上面用ioutil方法来拷贝一个文件，但是拷贝文件的话，还有一个更高效率的文件，就是io模块的copy方法。具体代码如下：

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "io"
13     "os"
14 )
15 
16 var (
17     SourceFile string  //源数据的文件
18     DestinationFile string        //拷贝的文件
19 )
20 
21 func CopyFile(dstName, srcName string) (written int64, err error) {
22     src, err := os.Open(srcName)
23     if err != nil {
24         return
25     }
26     defer src.Close()
27     dst, err := os.OpenFile(dstName, os.O_WRONLY|os.O_CREATE, 0644)
28     if err != nil {
29         return
30     }
31     defer dst.Close()
32     return io.Copy(dst, src)
33 }
34 
35 func main() {
36     SourceFile = "E:\\Code\\Golang\\Golang_Program\\文件处理\\我有一只小毛驴.txt"
37     DestinationFile  = "E:\\Code\\Golang\\Golang_Program\\文件处理\\我有一只小毛驴.bak"
38     CopyFile(DestinationFile, SourceFile)
39     fmt.Println("Copy done!")
40 }
41 
42 
43 
44 #以上代码执行结果如下：
45 Copy done!

 3.将文件的歌曲信息重定向到一个新文件

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "bufio"
12     "fmt"
13     "os"
14     "io"
15 )
16 
17 var (
18     OldFile = "E:\\Code\\Golang\\Golang_Program\\文件处理\\我有一只小毛驴.txt"
19     NewFile = "E:\\Code\\Golang\\Golang_Program\\文件处理\\歌曲信息.txt"
20     Counts int  //用于统计当前的行数。
21 )
22 
23 func main() {
24     inputFile, _ := os.Open(OldFile)
25     outputFile, _ := os.OpenFile(NewFile, os.O_WRONLY|os.O_CREATE, 0666)
26     defer inputFile.Close()
27     defer outputFile.Close()
28     inputReader := bufio.NewReader(inputFile)
29     for {
30         Counts ++
31         inputString, _, readerError := inputReader.ReadLine()
32         if readerError == io.EOF {
33             break
34         }
35         outputString := string([]byte(inputString))+ "\n"
36         if Counts < 7 {
37             outputFile.WriteString(outputString)
38         }
39     }
40     fmt.Println("文件加载完毕！")
41 }
42 
43 
44 
45 #以上代码执行结果如下：
46 文件加载完毕！

4.使用接口的实际例子：fmt.Fprintf

 1 /*
 2 #!/usr/bin/env gorun
 3 @author :yinzhengjie
 4 Blog:http://www.cnblogs.com/yinzhengjie/tag/GO%E8%AF%AD%E8%A8%80%E7%9A%84%E8%BF%9B%E9%98%B6%E4%B9%8B%E8%B7%AF/
 5 EMAIL:[email protected]
 6 */
 7 
 8 package main
 9 
10 import (
11     "fmt"
12     "os"
13     "bufio"
14 )
15 
16 func main() {
17     fmt.Fprintf(os.Stdout, "[%s]\n", "Yinzhengjie") //fmt.Fprintf方法要求第一个参数必须有可写的方法，第二个参数用于定义格式化输出，第三个参数是具体的字符串。
18     buf := bufio.NewWriter(os.Stdout) //我们创建一个写入器名字叫做buf，注意，bufio.NewWriter方法需要传入的对象必须有一个可写的方法。
19     fmt.Fprintf(buf, "【%s】\n", "Golang")
20     buf.Flush() //在缓冲写入的最后千万不要忘了使用 Flush() ，否则最后的输出不会被写入。
21 }
22 
23 
24 
25 #以上代码执行结果如下：

转载于:https://www.cnblogs.com/craneboos/p/9831177.html