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

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

                                            作者:尹正杰

版权声明:原创作品,谢绝转载!否则将追究法律责任。

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

一.文件的读取姿势

 1 歌曲:我有一只小毛驴
 2 歌手:碧瑶
 3 专辑:《瑶谣摇》
 4 发行时间:2014-03-18
 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 不知怎么哗啦啦啦 摔了一身泥

我有一只小毛驴.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")

 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 }
时间: 2024-10-09 12:51:32

Golang的文件处理方式-常见的读写姿势的相关文章

java.io几种读写文件的方式

一.Java把这些不同来源和目标的数据都统一抽象为数据流. Java语言的输入输出功能是十分强大而灵活的. 在Java类库中,IO部分的内容是很庞大的,因为它涉及的领域很广泛:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流. 这里介绍几种读写文件的方式 二.InputStream.OutputStream(字节流) //读取文件(字节流) InputStream in = new FileInputStream("d:\\1.txt"); //写入相应的文件

第八天 文件的读,写,追加,读写,写读,seek()光标的移动,修改文件以及另一种打开文件的方式

主要内容:    1.初始文件操作 2.只读( r,rb ) 3.只写( w,wb ) 4.追加( a ,ab) 5.读写( r+ ) 6.写读( w+ ) 7.追加写读 ( a+ ) 8.其他操作方法 9.文件的修改以及另一种打开文件句柄的方式 一.初始文件的操作    使用python来读写文件是非常简单的操作. 我们使用open()函数来打开?个文件, 获取到文件句柄. 然后通过文件句柄就可以进行各种各样的操作了. 根据打开方式的不同能够执行的操作也会有相应的差异. 打开文件的方式: r,

python下通过os模块和shutil模块进行文件处理方式

python下通过os模块和shutil模块进行文件处理方式 得到当前工作目录路径:os.getcwd() 获取指定目录下的所有文件和目录名:os.listdir(dir) 删除文件:os.remove(file) 删除多个目录:os.removedirs(r"/home") 检测路径是否为文件:os.path.isfile(path) 检测路径是否为目录:os.path.isdir(path) 判断是否为绝对路径:os.path.isabs(path) 检测路径是否存在:os.pat

转载:python文件打开方式详解——a、a+、r+、w+区别

第一步 排除文件打开方式错误: r只读,r+读写,不创建 w新建只写,w+新建读写,会将文件内容清零 (以w方式打开,不能读出.w+可读写) **w+与r+区别: r+:可读可写,若文件不存在,报错:w+: 可读可写,若文件不存在,创建 r+与a+区别: [python] view plain copy print? <span style="background-color: rgb(255, 255, 255);">fd = open("1.txt"

Linux下常用的文件传输方式介绍与比较

参考链接:http://mingxinglai.com/cn/2014/03/copy-file-in-linux/ 本文介绍了linux之间传输文件的几种方式,并通过具体实验测试了几种文件传输方式之间的传输速度.这篇文章是我一次作业的实验报告,我经常查看这个文档,所以贴出来方便自己查略. ###0. 实验环境以及实验数据 实验环境: 两台装有Ubuntu的电脑,两台电脑位于同一个局域网中,传输速度约4.1MB/s. 实验数据: 使用MySQL的日志文件(ib_logfile0)进行测试,日志文

【转】python文件打开方式详解——a、a+、r+、w+区别

原文地址:http://blog.csdn.net/ztf312/article/details/47259805 第一步 排除文件打开方式错误: r只读,r+读写,不创建 w新建只写,w+新建读写,二者都会将文件内容清零 (以w方式打开,不能读出.w+可读写) **w+与r+区别: r+:可读可写,若文件不存在,报错:w+: 可读可写,若文件不存在,创建 r+与a+区别: fd = open("1.txt",'w+') fd.write('123') fd = open("

python文件打开方式详解——a、a+、r+、w+区别

出处: http://blog.csdn.net/ztf312/ 第一步 排除文件打开方式错误: r只读,r+读写,不创建 w新建只写,w+新建读写,二者都会将文件内容清零 (以w方式打开,不能读出.w+可读写) w+与r+区别: r+:可读可写,若文件不存在,报错:w+: 可读可写,若文件不存在,创建 r+与a+区别: [python] view plain copy print? fd = open("1.txt",'w+') fd.write('123') fd = open(&

部署audit监控文件、加固常见服务的安全、使用diff和patch工具打补丁

部署audit监控文件.加固常见服务的安全.使用diff和patch工具打补丁 要求熟悉audit审计工具的基本使用,完成以下任务操作: 使用audit监控/etc/ssh/sshd_config 当该文件发生任何变化即记录日志 通过手动和ausearch工具查看日志内容 审计的目的是基于事先配置的规则生成日志,记录可能发生在系统上的事件(正常或非正常行为的事件),审计不会为系统提供额外的安全保护,但她会发现并记录违反安全策略的人及其对应的行为. 审计能够记录的日志内容: a) 日期与事件以及事

java多种文件复制方式以及效率比较

1.背景 java复制文件的方式其实有很多种,可以分为 传统的字节流读写复制FileInputStream,FileOutputStream,BufferedInputStream,BufferedOutputStream 传统的字符流读写复制FileReader,FileWriter,BufferWriter,BufferedWriter,BufferedReader NIO系列的FileChannel FileChannel+缓冲 java.nio.Files.copy() 第三方包中的Fi