PayneのWebSite

Every day

0%

使用Golang操作文件的那些事儿

发表于 更新于 分类于 Valine：
本文字数： 1.8k 阅读时长 ≈ 2 分钟

Golang 文件操作

Os模块的使用与源码研究

文件：计算机中的文件是存储在外部介质（通常是磁盘）上的数据集合，文件分为文本文件和二进制文件。例如咱们常见的文件后缀名.exe,.txt
,‘.word’…等等

文件的基本操作可简单分为增、删两类，也就是咱们所说的CURD(增删改查)
，也是基于此两类操作。可简单理解为打开文件夹、CURD、关闭文件夹。结束～

golang对于文件基本上都是基于Golang的os模块，那让我们一起了解一下，那么Golang是如何对文件进行操作呢。Let’s
Go~

打开文件

Golang中打开文件使用os.Open模块,官方os.open部分源码如下：

1
2
3
4
5
6
7
8
// os.Open
// Open opens the named file for reading. If successful, methods on
// the returned file can be used for reading; the associated file
// descriptor has mode O_RDONLY.
// If there is an error, it will be of type *PathError.
func Open(name string) (*File, error) {
 return OpenFile(name, O_RDONLY, 0)
}

Open打开命名文件以供读取。如果成功，则可以使用返回文件上的方法进行读取；关联的文件。描述符的模式为O_RDONLY。
如果有错误，它将是* PathError类型。

它接收一个string 类型的变量name,返回两个值，File的指针和错误error。那么我们使用它打开文件的的时候就需要这样做

1
2
fileObj, err := os.Open(name string)
// 其中os.Open中的name为路径Path

基础使用的介绍暂且为止，其实我们更应该关心的应该是OpenFile(name, O_RDONLY, 0)
，这个函数到底干了啥，我们追踪一下这个函数(在GoLang编辑器中， mac可以直接使用command +
鼠标左键直接进入，Win可以使用ctrl + 鼠标左键)，如下:

1
2
3
4
5
6
7
8
9
10
11
func OpenFile(name string, flag int, perm FileMode) (*File, error) {
 testlog.Open(name)
 f, err := openFileNolog(name, flag, perm)
 if err != nil {
  return nil, err
 }
 f.appendMode = flag&O_APPEND != 0

 return f, nil
}
// OpenFile是广义的open调用；大多数用户将使用Open 或Create代替。它打开带有指定标志的命名文件（O_RDONLY等）。如果该文件不存在，并且传递了O_CREATE标志，则会使用模式perm（在umask之前）创建该文件。如果成功，返回文件上的方法可以用于I / O。 如果有错误，它将是* PathError类型。

这个文件全部内容还是有点分量的，有信息的伙伴，可以详细的阅读一下全部内容。暂且为止

那让我们实践一下，使用Golang打开文件，如下

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

import (
 "fmt"
 "os"
)

func main() {
 // 打开此文件，./main.go为相对路径。在这里是此文件
 fileObj, err := os.Open("./main.go")
 // 异常处理
 if err != nil {
  fmt.Printf("Open File Error Message:%#v\n", err)
  return
 }
 // 尝试打印(此处输出的为地址值)
 fmt.Println(&fileObj)
 // defer 关闭文件
 defer fileObj.Close()
}

以防忘记关闭文件，造成bug，我们在这里使用defer + 关闭。

注意：在编辑器中并不建议直接使用鼠标右键运行，这样可能会导致路径错误。大部分的编辑器都并不是只运行此文件!!!

1
Open File Error Message:&os.PathError{Op:"open", Path:"./main.go", Err:0x2}

如果你遇见了类似的错误，你可以直接在终端中，切换到当前路径。使用go run main.go，直接运行。这样就可以直接得到正确的结果啦

读取文件

打开文件之后，那么我们可以就可以对他们进行操作了，我们在这里主要演示一下读取文件的操作。还是老样子，先看一下主要的相关源码，如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// FileObj.Read()
func (f *File) Read(b []byte) (n int, err error) {
 if err := f.checkValid("read"); err != nil {
  return 0, err
 }
 n, e := f.read(b)
 return n, f.wrapErr("read", e)
}

// f.read(b)
func (f *File) read(b []byte) (n int, err error) {
 n, err = f.pfd.Read(b)
 runtime.KeepAlive(f)
 return n, err
}

FileObj.Read()

示例化接受文件的地址值(也就是咱们前面打开获取到的结果)，接受切片的字节，返回读取的内容，以及错误

在此函数中首先检查是否为有效的读取，然后在进行f.read(b)的操作,接受其返回结果。

f.read(b)

在这里，主要检测是否在读取，如果是那么返回本次的读取内容

从以上我们不难看出，其实读取文件是读取文件内部的字节

那么更具FileObj.Read()，我们可以了解它基本的使用方法，如下

1
func (f *File) Read(b []byte) (n int, err error)

读取部分的示例代码如下：

在这里我们需要考虑：是否能够正常读取？是否读完了？具体请看异常处理部分

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 读取文件
 // 定义每次读取的大小
 //var tmp = make([]byte, 128)
 var tmp  [128]byte

 // n:从开始到结尾的内容
 n, err := fileObj.Read(tmp[:])
 // 异常处理
 if err != nil {
  fmt.Printf("Read of File Error, ErrorMessage:%#v\n", err)
  return
 }
 if err == io.EOF {
  fmt.Println("文件读完了")
  return
 }
 fmt.Printf("读取了%d个字节\n", n)
 fmt.Printf("读取到的内容：\n%s",tmp[:])

输出结果如下：

以上很明显是并没有读完的仅读取了部分，原始的全部代码如下

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
package main

import (
 "fmt"
 "io"
 "os"
)

func main() {
 // 打开此文件，./main.go为相对路径。在这里是此文件
 fileObj, err := os.Open("./main.go")
 // 异常处理
 if err != nil {
  fmt.Printf("Open of File Error, ErrorMessage:%#v\n", err)
  return
 }
 // 尝试打印(此处输出的为地址值)
 fmt.Println(&fileObj)
 // defer 关闭文件
 defer fileObj.Close()

 // 读取文件
 // 定义每次读取的大小
 //var tmp = make([]byte, 128)
 var tmp  [128]byte

 // n:从开始到结尾的内容
 n, err := fileObj.Read(tmp[:])
 // 异常处理
 if err != nil {
  fmt.Printf("Read of File Error, ErrorMessage:%#v\n", err)
  return
 }
 if err == io.EOF {
  fmt.Println("文件读完了")
  return
 }
 fmt.Printf("读取了%d个字节\n", n)
 fmt.Printf("读取到的内容：\n%s",tmp[:])
}

完整读取

for无线循环读取

由于以上我们并没有读取完整个文件，那么我需要读取全部的该怎么办呢？一个方法是不断的读取下去，然后和在一起就是完整的内容了，示例代码如下

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
package main

import (
 "fmt"
 "io"
 "os"
)

func main() {
 // 打开此文件，./main.go为相对路径。在这里是此文件
 fileObj, err := os.Open("./main.go")
 // 异常处理
 if err != nil {
  fmt.Printf("Open of File Error, ErrorMessage:%#v\n", err)
  return
 }
 // 尝试打印(此处输出的为地址值)
 fmt.Println(&fileObj)
 // defer 关闭文件
 defer fileObj.Close()
 // 循环读取文件
 var content []byte
 var tmp = make([]byte, 128)
 for {
  n, err := fileObj.Read(tmp)
  if err == io.EOF {
   fmt.Println("文件读完了")
   break
  }
  if err != nil {
   fmt.Printf("Read of File Error, ErrorMessage:%#v\n", err)
   return
  }
  content = append(content, tmp[:n]...)
 }
 fmt.Println(string(content))
}

主要的思路为：无限循环去读取，读完了之后break掉。然后把读取的内容合并起来

这种读取虽然可行，不过是否有点太麻烦了，那么有什么更简便的方式呢？答案当然是有的，bufio读取

bufio读取

bufio是在file的基础上封装了一层API，支持更多的功能。

主要的部分源码如下所示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// bufio.NewReader
// NewReader returns a new Reader whose buffer has the default size.
func NewReader(rd io.Reader) *Reader {
 return NewReaderSize(rd, defaultBufSize)
}

// NewReaderSize
// NewReaderSize returns a new Reader whose buffer has at least the specified
// size. If the argument io.Reader is already a Reader with large enough
// size, it returns the underlying Reader.
func NewReaderSize(rd io.Reader, size int) *Reader {
 // Is it already a Reader?
 b, ok := rd.(*Reader)
 if ok && len(b.buf) >= size {
  return b
 }
 if size < minReadBufferSize {
  size = minReadBufferSize
 }
 r := new(Reader)
 r.reset(make([]byte, size), rd)
 return r
}

它简便的原因是因为已经帮我们定义了文件的指针，以及它还定义了缓冲区，这样我们使用它来读取更加的快与便捷。

bufio.NewReader语法格式

1
2
func NewReader(rd io.Reader) *Reader 
// 其中rd为我们打开文件的对象

使用如下

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
package main

import (
 "bufio"
 "fmt"
 "io"
 "os"
)

func main() {
 // 打开此文件，./main.go为相对路径。在这里是此文件
 fileObj, err := os.Open("./main.go")
 // 异常处理
 if err != nil {
  fmt.Printf("Open of File Error, ErrorMessage:%#v\n", err)
  return
 }
 // 尝试打印(此处输出的为地址值)
 fmt.Println(&fileObj)
 // defer 关闭文件
 defer fileObj.Close()
 // bufio读取
 reader := bufio.NewReader(fileObj)
 for {
  line, err := reader.ReadString('\n') //注意是字符
  if err == io.EOF {
   if len(line) != 0 {
    fmt.Println(line)
   }
   fmt.Println("文件读完了")
   break
  }
  if err != nil {
   fmt.Println("read file failed, err:", err)
   return
  }
  fmt.Print(line)
 }
}

输入结果如上，略。。。

搞了这么多，就没有一键读取的么？当然也是有的，让我们来了体验一下ioutil读取整个文件的愉悦。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main

import (
 "fmt"
 "io/ioutil"
)

// ioutil.ReadFile读取整个文件
func main() {
 content, err := ioutil.ReadFile("./main.go")
 if err != nil {
  fmt.Println("read file failed, err:", err)
  return
 }
 fmt.Println(string(content))
}

其内部的实现原理，先预测整个文件的大小。然后一次性全部读取。当然需要做好异常的准备哦

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
// ReadFile reads the file named by filename and returns the contents.
// A successful call returns err == nil, not err == EOF. Because ReadFile
// reads the whole file, it does not treat an EOF from Read as an error
// to be reported.
func ReadFile(filename string) ([]byte, error) {
 f, err := os.Open(filename)
 if err != nil {
  return nil, err
 }
 defer f.Close()
 // It's a good but not certain bet that FileInfo will tell us exactly how much to
 // read, so let's try it but be prepared for the answer to be wrong.
 var n int64 = bytes.MinRead

 if fi, err := f.Stat(); err == nil {
  // As initial capacity for readAll, use Size + a little extra in case Size
  // is zero, and to avoid another allocation after Read has filled the
  // buffer. The readAll call will read into its allocated internal buffer
  // cheaply. If the size was wrong, we'll either waste some space off the end
  // or reallocate as needed, but in the overwhelmingly common case we'll get
  // it just right.
  if size := fi.Size() + bytes.MinRead; size > n {
   n = size
  }
 }
 return readAll(f, n)
}

文件写入操作

os.OpenFile()函数能够以指定模式打开文件，从而实现文件写入相关功能。

1
2
3
func OpenFile(name string, flag int, perm FileMode) (*File, error) {
 ...
}

其中：

name：要打开的文件名 flag：打开文件的模式。 模式有以下几种：

模式含义
os.O_WRONLY只写
os.O_CREATE创建文件
os.O_RDONLY只读
os.O_RDWR读写
os.O_TRUNC清空
os.O_APPEND追加

perm：文件权限，一个八进制数。r（读）04，w（写）02，x（执行）01。

Write和WriteString

1
2
3
4
5
6
7
8
9
10
11
func main() {
 file, err := os.OpenFile(test.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
 if err != nil {
  fmt.Println("open file failed, err:", err)
  return
 }
 defer file.Close()
 str := "hello"
 file.Write([]byte(str))       //写入字节切片数据
 file.WriteString("hello") //直接写入字符串数据
}

bufio.NewWriter

1
2
3
4
5
6
7
8
9
10
11
12
13
func main() {
 file, err := os.OpenFile("xx.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
 if err != nil {
  fmt.Println("open file failed, err:", err)
  return
 }
 defer file.Close()
 writer := bufio.NewWriter(file)
 for i := 0; i < 10; i++ {
  writer.WriteString("hello") //将数据先写入缓存
 }
 writer.Flush() //将缓存中的内容写入文件
}

ioutil.WriteFile

1
2
3
4
5
6
7
8
func main() {
 str := "hello"
 err := ioutil.WriteFile("./asd.txt", []byte(str), 0666)
 if err != nil {
  fmt.Println("write file failed, err:", err)
  return
 }
}

so cool～

相关文章