golang编程之文件操作

最新推荐文章于 2024-02-06 16:59:08 发布
最新推荐文章于 2024-02-06 16:59:08 发布
阅读量4.7k 收藏 2
点赞数 2
分类专栏： 大规模分布计算(云、搜索引擎) 文章标签： go

http://blog.chinaunix.net/uid-24774106-id-3993609.html


操作文件是任何编程语言都绕不过，要掌握一门语言，知道如何操作文件是必不可少的，今天学习了下golang对文件操作的支持。
    golang对文件的支持是在os package里。我无意将本文写成官方文档的模样，我只是想讨论如何利用这些接口操作文件。
    OPEN
     熟悉文件系统的人都知道，open是整个文件系统中最复杂的接口之一。熟悉C语言的都知道，C语言中有open和creat，接口如下：

  1.        #include <sys/types.h>
  2.        #include <sys/stat.h>
  3.        #include <fcntl.h>

  5.        int open(const char *pathname, int flags);
  6.        int open(const char *pathname, int flags, mode_t mode);

  8.        int creat(const char *pathname, mode_t mode)
    对C的open而言，如果flag里面有了O_CREAT,那么必须带上mode参数，制定创建文件时的perm，如果文件已经存在了，这个O_CREAT标志就无效了（除非O_EXCL标志被指定。 除了O_CREAT，还有很多的标志  

    O_RDONLY
 
    O_WRONLY
    
    O_RDWR

    O_DIRECT

    O_APPEND

    O_TRUNC
    。。。。
    这些标志位基本是顾名思义，对于open这种很复杂很综合的文件操作，golang中对应的是OpenFile   
  1. func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
    我们看到了也有flag，也有FileMode.比如说我要读写打开一个文件，如果不存在就创建，如果存在，就追加写，如何写go 代码？
  1.     f,err := os.OpenFile("test.txt",os.O_CREATE|os.O_APPEND|os.O_RDWR,0660)
  2.     if(err != nil){
  3.         panic(err)
  4.     }
    我们看到了，golang中也有这些标志（注意O_CREATE,在C语言中，是O_CREAT）,我在上面代码片段中用了几个标志
  1. const (
  2.         O_RDONLY int = syscall.O_RDONLY // open the file read-only.
  3.         O_WRONLY int = syscall.O_WRONLY // open the file write-only.
  4.         O_RDWR int = syscall.O_RDWR // open the file read-write.
  5.         O_APPEND int = syscall.O_APPEND // append data to the file when writing.
  6.         O_CREATE int = syscall.O_CREAT // create a new file if none exists.
  7.         O_EXCL int = syscall.O_EXCL // used with O_CREATE, file must not exist
  8.         O_SYNC int = syscall.O_SYNC // open for synchronous I/O.
  9.         O_TRUNC int = syscall.O_TRUNC // if possible, truncate file when opened.
  10.       )
     C语言中有creat，没有则创建，有则截断写，本质等于O_WRONLY | O_CREAT | O_TRUNC
  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. int creat (const char *name, mode_t mode)
    Ken Thompson大神曾经戏言，漏掉creat系统调用中的e字母是他设计Unix最后悔的事情，呵呵看起来老爷子接收了教训，没有犯同样的拼写错误，golang中对应的接口是Create（大神这一次没有拼写错）
  1. func Create(name string) (file *File, err error)
    和C的creat系统调用相比，少了mode入参，默认是0x666（before umask），同时标志不再是O_WRONLY,而是O_RDWR，仍然带创建标志位，仍然带截断标志。
    golang中的Open和C中的open就不能相比了（和C中的open PK那是OpenFile的事儿）接口如下：    
  1. func Open(name string) (file *File, err error)
    直白说，就是带O_RDONLY的open，太菜了。

    CLOSE
    这个接口无甚好说。接口如下
  1. func (f *File) Close() error
    但说接口没啥说的，但是golang提供了defer，这是一个我认为很赞的特点，就是将不得不做的cleanup放到defer去做。
    我们写C的人，经常遇到了这种代码  
  1. fd = open(...)
  2. if(fd < 0 )
  3. {
  4.     ...
  5. }

  7. if (failed_1)
  8. {
  9.    ...
  10.    close(fd);
  11.    ....
  12. }

  14. if(faile_2)
  15. {
  16.     ...
  17.     close(fd);
  18.     ...
  19. }
  20. ....
    只要打开了文件，每次异常处理都要想着close，否则句柄泄漏，太烦。所以C语言是一门你要小心伺候的语言。
    go提供了defer解决这种困境，后面不用时刻惦记close，函数退出前，会执行close。
  1.     f,err := os.OpenFile("test.txt",os.O_CREATE|os.O_APPEND|os.O_RDWR,0660)
  2.     if(err != nil){
  3.         panic("open file failed")
  4.     }
  5.     defer f.Close()
  6.     ...
    READ和WRITE
    read和write是比较重要的文件操作了，这是C的接口。
  1.   #include <unistd.h>

  3.   ssize_t write(int fd, const void *buf, size_t count);
  4.   ssize_t read(int fd, void *buf, size_t count)
    对于golang，接口如下：  
  1. func (f *File) Read(b []byte) (n int, err error)
  2. func (f *File) ReadAt(b []byte, off int64) (n int, err error)

  4. func (f *File) Write(b []byte) (n int, err error)
  5. func (f *File) WriteAt(b []byte, off int64) (n int, err error)
  6. func (f *File) WriteString(s string) (ret int, err error)
   看到代码片段，学习使用读写接口：  
  1.     read_buf := make([]byte,32)
  2.     var pos int64 = 0
  3.     for{

  5.         n,err := f.ReadAt(read_buf,pos)
  6.         if err != nil && err != io.EOF{
  7.             panic(err)
  8.         }
  9.         if n == 0{
  10.             fmt.Printf("\nfinish read\n")
  11.             break
  12.         }
  13.         fmt.Printf("%s",string(read_buf[:n]))
  14.         pos = pos +(int64)(n)
  15.     }
    在看一个代码片段：
  1.     var buff = make([]byte,1024)
  2.     for{
  3.         n,err := fi.Read(buff)
  4.         if err != nil && err != io.EOF{
  5.             panic(err)
  6.         }
  7.         
  8.         if n == 0{
  9.             break
  10.         }

  12.         if _,err := fo.Write(buff[:n]); err != nil{
  13.             panic(err)
  14.         }

  16.     }
    最后，我写了一个完整的代码，完成简单cp功能，就叫mycp  
  1. manu@manu-hacks:~/code/go/self$ cat mycp.go 
  2. package main
  3. import "fmt"
  4. import "os"
  5. import "io"

  7. func usage(){
  8.     fmt.Printf("%s %s %s\n",os.Args[0],"filename" , "newfile")
  9. }


  12. func main(){
  13.     
  14.     if len(os.Args) != 3{
  15.         usage()
  16.         return 
  17.     }

  19.     filename_in := os.Args[1]
  20.     fi,err := os.Open(filename_in)
  21.     if err != nil{
  22.         panic(err)
  23.     }
  24.     defer fi.Close()

  26.     filename_out := os.Args[2]
  27.     fo,err := os.Create(filename_out)
  28.     if err != nil{
  29.         panic(err)
  30.     }
  31.     defer fo.Close()


  34.     var buff = make([]byte,1024)
  35.     for{
  36.         n,err := fi.Read(buff)
  37.         if err != nil && err != io.EOF{
  38.             panic(err)
  39.         }
  40.         
  41.         if n == 0{
  42.             break
  43.         }

  45.         if _,err := fo.Write(buff[:n]); err != nil{
  46.             panic(err)
  47.         }

  49.     }
  50. }
    执行结果：  
  1. manu@manu-hacks:~/code/go/self$ ./mycp test.txt test.bak
  2. manu@manu-hacks:~/code/go/self$ diff test.txt test.bak 
  3. manu@manu-hacks:~/code/go/self$ cat test.txt 
  4. this is test file created by go
  5. if not existed ,please create this file
  6. if existed, Please write append
  7. hello world,hello go
  8. this is test file created by go
  9. if not existed ,please create this file
  10. if existed, Please write append
  11. hello world,hello go

参考文献
1 Linux system program
2  golang os package
3 StackOverflow  How to read/write from/to file?


上篇博文学习了go语言的对FILE的基本操作，我突然想到，文件一个很常用的场景是逐行处理，比如我们的linux下的神器awk，比如我之前写的KMean++算法处理NBA后卫的数据。对于C语言而言，fgets就解决了这个问题，看下C语言中fgets的接口：    

  1. char *fgets(char *s, int size, FILE *stream);
    当然了首先要fopen，获得文件描述符，然后可以fgets按行获取。
    我给出个C程序，完成基本的cat功能，支持-n选项，带了-n则打印出行号：
  1. manu@manu-hacks:~/code/c/self/readline$ cat mycat.c 
  2. #include<stdio.h>
  3. #include<stdlib.h>
  4. #include<string.h>
  5. #include<errno.h>



  9. int num_flag = 0;

  11. int cat(FILE* file)
  12. {
  13.     char buf[1024] = {0};
  14.     int line_no = 1;
  15.     while(fgets(buf,1024,file) != NULL)
  16.     {
  17.         if(num_flag != 0)
  18.         {
  19.             fprintf(stdout,"%5d %s",line_no,buf);
  20.         }
  21.         else
  22.         {
  23.             fprintf(stdout,"%s",buf);
  24.         }
  25.         line_no++;
  26.     }

  28. }

  30. int main(int argc,char* argv[])
  31. {
  32.     int i = 0 ;
  33.     int j = 0 ;
  34.     int file_exist = 0;
  35.     FILE* file = NULL;

  37.     for(i = 1; i < argc;i++)
  38.     {
  39.         if(strcmp(argv[i],"-n") == 0)
  40.         {
  41.             num_flag = 1;
  42.             break;
  43.         }
  44.     }

  46.     for(j = 1; j<argc ;j++)
  47.     {
  48.         if(j==i)
  49.             continue;

  51.         file_exist = 1;

  53.         file = fopen(argv[j],"rb");
  54.         if(file == NULL)
  55.         {
  56.             fprintf(stderr,"%s:err reading from %s:%s\n",
  57.                     argv[0],argv[j],strerror(errno));
  58.             continue;
  59.         }

  61.         cat(file);
  62.     }

  64.     if(file_exist == 0)
  65.     {
  66.         cat(stdin);
  67.     }
  68. }
    golang怎么办?
    golang 提供了package bufio。bufio.NewReader()创建一个默认大小的readbuf，当然，也可以bufio.NewReaderSize
  1. func NewReader(rd io.Reader) *Reader
  2.     NewReader returns a new Reader whose buffer has the default size(4096).


  5. func NewReaderSize(rd io.Reader, size int) *Reader
  6.     NewReaderSize returns a new Reader whose buffer has at least the
  7.     specified size. If the argument io.Reader is already a Reader with large
  8.     enough size, it returns the underlying Reader.
    bufio提供

  1. func (b *Reader) ReadByte() (c byte, err error)
  2.     ReadByte reads and returns a single byte. If no byte is available,
  3.     returns an error.

  5. func (b *Reader) ReadBytes(delim byte) (line []byte, err error)
  6.     ReadBytes reads until the first occurrence of delim in the input,
  7.     returning a slice containing the data up to and including the delimiter.
  8.     If ReadBytes encounters an error before finding a delimiter, it returns
  9.     the data read before the error and the error itself (often io.EOF).
  10.     ReadBytes returns err != nil if and only if the returned data does not
  11.     end in delim. For simple uses, a Scanner may be more convenient.

  13. func (b *Reader) ReadString(delim byte) (line string, err error)
  14.     ReadString reads until the first occurrence of delim in the input,
  15.     returning a string containing the data up to and including the
  16.     delimiter. If ReadString encounters an error before finding a delimiter,
  17.     it returns the data read before the error and the error itself (often
  18.     io.EOF). ReadString returns err != nil if and only if the returned data
  19.     does not end in delim. For simple uses, a Scanner may be more
  20.     convenient.
    ReadByte这个接口，和C语言中fgetc很接近，每次读取一个字节。ReadBytes和ReadString都可以实现逐行读取，只要delim设置为'\n'.
    看一下go语言实现的简易mycat：    
  1. manu@manu-hacks:~/code/go/self$ cat mycat.go 
  2. package main
  3. import "fmt"
  4. import "os"
  5. import "io"
  6. import "flag"
  7. import "bufio"

  9. var num_flag = flag.Bool("n",false,"num each line")

  11. func usage(){
  12.     fmt.Printf("%s %s\n",os.Args[0],"filename")
  13. }



  17. func cat(r *bufio.Reader){
  18.     i := 1
  19.     for {
  20.         //buf,err := r.ReadBytes('\n')
  21.         buf,err := r.ReadString('\n')
  22.         if err == io.EOF{
  23.             break
  24.         }

  26.         if *num_flag{
  27.             fmt.Fprintf(os.Stdout,"%5d %s",
  28.                         i,buf)
  29.             i++
  30.         }else{
  31.             fmt.Fprintf(os.Stdout,"%s",buf)
  32.         }

  34.     }
  35.     return 
  36. }


  39. func main(){

  41.     flag.Parse()
  42.     if(flag.NArg() == 0){
  43.         cat(bufio.NewReader(os.Stdin))
  44.     }

  46.     for i:=0;i<flag.NArg();i++{
  47.         f,err := os.OpenFile(flag.Arg(i),os.O_RDONLY,0660)
  48.         if err != nil{
  49.             fmt.Fprintf(os.Stderr,"%s err read from %s : %s\n",
  50.             os.Args[0],flag.Arg(0),err)
  51.             continue
  52.         }

  54.         cat(bufio.NewReader(f))
  55.         f.Close()
  56.     }
  57. }
    单纯考虑逐行读取，line by line， bufio的文档也说
  1. For simple uses, a Scanner may be more convenient.
    先看文档：
  1. func NewScanner(r io.Reader) *Scanner
  2.     NewScanner returns a new Scanner to read from r. The split function
  3.     defaults to ScanLines.

  5. func (s *Scanner) Text() string
  6.     Text returns the most recent token generated by a call to Scan as a
  7.     newly allocated string holding its bytes.

  9. func (s *Scanner) Err() error
  10.     Err returns the first non-EOF error that was encountered by the Scanner.

  12. func (s *Scanner) Scan() bool
  13.     Scan advances the Scanner to the next token, which will then be
  14.     available through the Bytes or Text method. It returns false when the
  15.     scan stops, either by reaching the end of the input or an error. After
  16.     Scan returns false, the Err method will return any error that occurred
  17.     during scanning, except that if it was io.EOF, Err will return nil.
    怎么用Scanne呢?   
  1. func cat(scanner *bufio.Scanner) error{

  3.     for scanner.Scan(){
  4.         fmt.Println(scanner.Text())    
  5.       //fmt.Fprintf(os.Stdout,"%s\n",scanner.Text())
  6.     }

  8.     return scanner.Err()
  9. }
    注意，为啥执行Scan，Text()函数就能返回下一行呢？因为默认的分割函数就是ScanLines.如你有特殊的需求来分割，func (s *Scanner) Split(split SplitFunc)
这个函数可以制定SplitFunc。你可以定制自己的分割函数。
    需要注意的是，Scan会将分割符号\n去除，如果Fprintf输出的话，不添加\n打印，会出现没有换行的现象，如下所示
  1. fmt.Fprintf(os.Stdout,"%s",scanner.Text())
  1. manu@manu-hacks:~/code/go/self$ go run mycat_v2.go test.txt 
  2. this is test file created by goif not existed ,please create this fileif existed, Please write appendhello world,hello gothis is test file created by goif not existed ,please create this fileif existed, Please write appendhello world,hello gomanu@manu-hacks:~/code/go/self$ cat test.txt 
  3. this is test file created by go
  4. if not existed ,please create this file
  5. if existed, Please write append
  6. hello world,hello go
  7. this is test file created by go
  8. if not existed ,please create this file
  9. if existed, Please write append
  10. hello world,hello go
    调用部分的代码如下：
  1.         f,err := os.OpenFile(flag.Arg(i),os.O_RDONLY,0660)
  2.                  ...
  3.         error := cat(bufio.NewScanner(f))
  4.         if err != nil{
  5.             fmt.Fprintf(os.Stderr,"%s err read from %s : %s\n",
  6.             os.Args[0],flag.Arg(i),error)
  7.         }
    推荐使用Scanner，使用比较简单。
参考文献：
1 godoc bufio



blade2001
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大家一起学Golang——文件操作
01-08
大家一起学Golang——文件操作 文件操作 对文件操作几乎每个编程语言都有，Go后端开发中对日志操作较多。 创建 、打开文件 创建两种方式： func Create(name string) (file *FIle, err Error) 返回文件对象，默认...
learning-golang:学习Golang编程
06-04
Golang教程 根据的修改 1. 1.1. 1.2. 1.3. 1.4. 1.5. 1.6. 2. 2.1. 2.2. 2.3. 2.4. 2.5. 2.6. interface 2.7. 并发 2.8. 小结 3.Web基础 3.1 web工作方式 3.2 Go搭建一个简单的web服务 3.3 Go如何使得web工作 3.4 Go...
golang IO操作
qq_49723651的博客
12-19 1332
golang IO操作 文章目录golang IO操作file句柄更简单的ioutilio.Writer和io.Reader接口io.LimitReader函数 file句柄 os.Open(name string)方法以只读方式打开文件，os 包还提供了 os.OpenFile(name string, flag int, perm FileMode)方法，通过指定额外的 读写方式 和 文件权限参数，使文件操作变得更为灵活。 其中，flag 有以下几种常用的值： os.O_CREATE: crea
Golang中文件目录操作的实现
周小末天天开心的博客
05-30 3261
文件和文件目录的概念以及文件目录中读取文件、写入文件、复制文件
Golang文件操作大全
最新发布
什么都不会
02-06 392
【代码】Golang文件操作大全。
Go 常用文件操作的示例
qunshuaizhao的博客
05-09 674
go、golang、文件操作
深入理解Golang Unix域socket通信
neweastsun的专栏
01-17 2894
unix域socket和网络socket在安全性方面有差异。unix域比网络更安全，因为它不需要对外暴露给网络，进行在同一台服务器上的进程间通信。unix域仅使用文件系统权限去控制访问，指定用户和组创建socket文件并仅有权限的用户和组才能访问进程。这意味着仅收取进程能连接至socket和交互数据。相反，网络socket暴露在网络上并任何机器都可以连接并访问，很容易受到恶意用户（如黑客和恶意软件）的攻击。网络socket使用tcp/udp协议，这些协议有他们自己安全机制，如加密和认证。
Go os,bufio,ioutil包 对文件读取写入小结 和文件/文件夹是否存在
小楼一夜听春雨，深巷明朝卖杏花
03-21 1102
对单个文件读取写入 带缓冲区bufio包 打开一个存在的文件，并且将原来的内容覆盖为新的内容。这里不需要创建文件所以不需要使用 os.O_CREATE。 os.O_TRUNC | os.O_WRONLY 以写的方式打开已经存在的文件，在写之前清空文件里面的内容。 fileSd,err := os.OpenFile("test.txt",os.O_TRUNC | os.O_WRONLY,os.ModePerm) if err != nil{ fmt.Println("open fil...
golang实现http server提供文件下载功能
01-20
Go（又称Golang）是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言。 罗伯特·格瑞史莫（Robert Griesemer），罗勃·派克（Rob Pike）及肯·汤普逊（Ken Thompson）于2007年9月开始设计...
Go语言，也被称为Golang，是由Google设计和开发的一种编程语言
10-11
标准库： Go语言的标准库包含了很多实用的包，例如网络编程、加密、文件操作等。 接口： Go语言的接口系统允许实现多态性，而不需要继承某个特定的类。 编译与执行： Go语言是编译型语言，编译后的二进制文件可以在...
goderive:Golang 中函数式编程、并发和泛型的代码生成
08-05
戈德利夫 goderive派生出您不想维护的普通 golang 函数，并使它们保持最新状态。 它通过解析未实现的函数的 go 代码来完成此操作，然后通过从输入参数类型派生它们的实现来为您生成这些函数。例子在下面的代码中， ...
Golang 中对文件 file 操作方法总结
qq_41123190的博客
01-21 1030
Golang 中对文件 file 操作方法总结 参考文章：https://www.cnblogs.com/pscc/p/12360415.html 1. 创建文件 func createFile(name string){ file, err := os.Create(name) if err != nil { log.Fatalln(err) } fmt.Println(file) } 2.判断文件是否存在 func checkFile(name string){ _, err := os
golang 读写文件的四种方式
热门推荐
whatday的专栏
01-11 2万+
读文件 读取的文件放在file/test：也就是file包下的test这个文件，里面写多一点文件 读文件方式一：利用ioutil.ReadFile直接从文件读取到[]byte中 func Read0() (string){ f, err := ioutil.ReadFile("file/test") if err != nil { fmt.Println(...
golang中的close函数
开心就好的专栏
08-19 1万+
close函数是用于关闭通道的。 官方解释（摘自close函数源代码注释）： The close built-in function closes a channel, which must be either bidirectional or send-only. It should be executed only by the sender, never the rec...
golang 覆盖写入文件 简介
whatday的专栏
11-15 9236
Python、Java的写文件默认函数操作默认是覆盖的，而是Golang的OpenFile函数写入默认是追加的 os.O_TRUNC 覆盖写入，不加则追加写入 覆盖写入实例： func WriteToFile(fileName string, content string) error { f, err := os.OpenFile(fileName, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644) if err != nil { fmt.
Go语言 Os.OpenFile函数
巍巍玮玮的博客
03-03 5925
参考 源码地址https://github.com/golang/go/blob/master/src/os/file_unix.go?name=release#76 文档解释https://studygolang.com/pkgdoc funcOpenFile func OpenFile(name string, flag int, perm FileMode) (file *File, err error) OpenFile是一个更一般性的文件打开函数，大多数调用者都应用Open...
Go_IO操作文件/目录
itzhuzhu的博客
02-07 5535
Go_IO操作文件/目录
系统调用
wuguinianjing的博客
11-02 244
系统调用的弊端 系统调用完成了应用程序和内核交流的工作,因此理论上只需要系统调用就可以完成一些程序，但是: 事实上，包括Linux，大部分操作系统的系统调用都有两个特点: 使用不便。 操作系统提供的系统调用接口往往过于原始，程序员须要了解很多与操作系统相关的细节。如果没有进行很好的包装，使用起来不方便。（包装使得抽象） 各个操作系统之间系统调用不兼容。 首先 Windows系统和Linux系统之间的系统调用就基本上完全不同，虽然它们的内容很多都一样，但是定义和实现大不一样。即使是同系列的操作系统的系
golang基础入门
10-20
15.文件操作：介绍golang中的文件操作。 16.goroutine和channel使用：介绍golang中的goroutine和channel的使用。 17.GO并发原理：介绍golang中的并发原理。 18.反射：介绍golang中的反射。 19.tcp网络编程：介绍...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值