打开和关闭文件

os.Open()函数能够打开一个文件，返回一个*file和一个err。对得到的文件调用Close文件能够关闭文件。

1
2
3
4
5
6
7
8
9
10
func readFromByIO(){
   //打开文件
   fileObj, err := os.Open("./main.go")
   if err != nil{
      fmt.Print("open file failed, err :%v", err)
      return
   }
   //关闭文件流
   defer fileObj.Close()
}

为防止文件忘记关闭，我们通常使用defer注册文件关闭语句。

读取文件

基本使用

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

他接受一个字节切片，返回读取的字节数组和可能的具体错误，读到文件末尾时会返回0和io.EOF

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
func readFromByIO(){
   //打开文件
   fileObj, err := os.Open("./main.go")
   if err != nil{
      fmt.Print("open file failed, err :%v", err)
      return
   }
   //关闭文件流
   defer fileObj.Close()
   //读文件
   var temp [128]byte
   for{
      //var temp = (make([]byte, 128)) //读取指定的长度
      n, err := fileObj.Read(temp[:])
      if err == io.EOF{
         return
      }
      if err != nil {
         fmt.Printf("read from file failed, err:%v", err)
         return
      }
      fmt.Printf("读取了%d个字dde节\n", n)
      fmt.Print(string(temp[:n]))
      if n < 128 {
         return
      }
   }
}

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读取文件
func readFromByBufferIO(){
   file, e := os.Open("./main.go")
   if e != nil {
      fmt.Println("文件读取失败")
      return
   }
   //记得关闭文件
   defer file.Close()
   //创建一个用来读取文件内容的对象
   reader := bufio.NewReader(file)
   for {
      s, e := reader.ReadString('\n')
      if e == io.EOF {
         fmt.Println("文件读取完毕")
         return
      }
      if e != nil {
         fmt.Println("文件读取失败")
      }
      fmt.Print(s)
   }
}

ioutil读取整个文件

1
2
3
4
5
6
7
8
9
//利用IOUtil读取整个文件
func readFromByIOUtil(){
   bytes, e := ioutil.ReadFile("./main.go")
   if e != nil {
      fmt.Println("文件读取失败")
      return
   }
   fmt.Println(string(bytes))
}

文件写入操作

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

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

其中：

name：要打开文件的名字 ,flag打开文件的模式，perm文件权限。

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

file写文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//普通方式写入文件
func writeByFile(){
   file, e := os.OpenFile("./a.txt", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
   defer file.Close()
   if e != nil {
      fmt.Println("文件创建失败")
      return
   }
   //通过byte切片写入文件
   file.Write([]byte("通过[]byte方式写文件\n"))
   //使用string方式写入文件
   file.WriteString("通过string方式写入文件\n")
   if e != nil {
      fmt.Println("文件写入失败")
      return
   }
}

bufio写文加

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//使用bufio写文件
func writeBybufIO(){
   file, e := os.OpenFile("./b.txt", os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0644)
   defer file.Close()
   if e != nil {
      fmt.Println("文件创建失败")
      return
   }
   writer := bufio.NewWriter(file)
   //将数据写入缓存
   writer.WriteString("通过string写文件")
   //将缓存中的数据写入文件
   writer.Flush()
}

ioutil写文件

1
2
3
4
5
6
7
8
//通过ioutil直接写文件
func writeByIOUtil(){
   var str string = "通过ioutil直接向文件内写文件"
   err := ioutil.WriteFile("./c.txt", []byte(str), 0644)
   if err != nil {
      fmt.Println("文件写如失败")
   }
}

复制文件

1
2
3
io.Copy(dest Writer, src Reader)(writter int64, err error){
    ...
}

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func main() {
   file, e := os.Open("./test.txt")
   if e != nil {
      fmt.Println("文件打开失败")
      return
   }
   defer file.Close()
   openFile, e := os.OpenFile("./copy.txt", os.O_WRONLY|os.O_CREATE, 0644)
   if e != nil {
      fmt.Println("文件创建失败")
      return
   }
   defer openFile.Close()
   io.Copy( openFile, file)
   if e != nil {
      fmt.Println("文件复制失败")
      return
   }
}