一篇文章带你搞定Go语言基础之文件操作

开发 后端
Hey,大家好呀,我是Go进阶者,这次咱们来说一下文件操作。文件操作就简单了,像打开word了,excel了,都是文件操作,当然,我们肯定是不能直接操作word的。 我们就从最简单的普通文件开始叭!

[[382352]]

前言

Hey,大家好呀,我是Go进阶者,这次咱们来说一下文件操作。

文件操作就简单了,像打开word了,excel了,都是文件操作,当然,我们肯定是不能直接操作word的

我们就从最简单的普通文件开始叭!

打开和关闭文件

  1. package main 
  2.  
  3. import "os" 
  4.  
  5. func main() { 
  6.     //os.Open是只读模式 
  7.     fileObj, err := os.Open("永不退缩.txt"
  8.     if err != nil { 
  9.         panic(err) 
  10.     //关闭文件 
  11.     fileObj.Close() 
  12.     //一般情况下使用这种方式关闭文件 
  13.     defer fileObj.Close() 

注:如果你使用的是Goland,在学习文件操作这一块时,尽量不要右击运行,因为查找文件路径不一样

尽可能的编译成.exe文件,这样找的就是当前目录

 

读取文件

读取指定大小

代码

  1. func main() { 
  2.     //os.Open是只读模式 
  3.     fileObj, err := os.Open("永不退缩.txt"
  4.     if err != nil { 
  5.         panic(err) 
  6.     var fileBytes = make([]byte,128) 
  7.     n, err := fileObj.Read(fileBytes) 
  8.     if err != nil { 
  9.         panic(err) 
  10.     fmt.Println(string(fileBytes[:n])) 
  11.     //一般情况下使用这种方式关闭文件 
  12.     defer fileObj.Close() 

执行结果

 

可以发现,根本就没有读取完,并且还乱码了。

读取整个文件

上述我们只读取了128个字节,一个中文3个字节,128/3,除下标点符号,应该是40个左右,明显不够

那该怎么办才能读取所有呢???

上述我们只读取了128个字节,我们可以在读取128个字节啊

然后找个罐子将每次读取的都装进去,读取完,装完,完美

代码

  1. func main() { 
  2.     //os.Open是只读模式 
  3.     fileObj, err := os.Open("永不退缩.txt"
  4.     if err != nil { 
  5.         panic(err) 
  6.     //一般情况下使用这种方式关闭文件 
  7.     defer fileObj.Close() 
  8.  
  9.     var 罐子 []string 
  10.     var 每次读取字节 = make([]byte,128) 
  11.     for
  12.         n, err := fileObj.Read(每次读取字节) 
  13.         //err == io.EOF表示读完了,一定要放在err != nil前面 
  14.         if err == io.EOF { 
  15.             break 
  16.         } 
  17.         if err != nil { 
  18.             panic(err) 
  19.         } 
  20.         var 每次读取字符串 = string(每次读取字节[:n]) 
  21.         罐子 = append(罐子,每次读取字符串) 
  22.     fmt.Println(罐子) 

执行结果

 

会发现还是有乱码,这是为啥???

这是因为我们每次都是按照字节来读取一部分,一部分的,但是中文是3个字节,所有有时候可能切错了,就出现了乱码

那咋办呢?没办法,默认的读取文件就这么点功能,更多功能,尽在bufio

bufio

bufio

可以理解为原生file操作的一个加强版,更牛叉,功能更多

还是上述这个文件,看看如何完美读取

代码

  1. func main() { 
  2.     //os.Open是只读模式 
  3.     fileObj, err := os.Open("永不退缩.txt"
  4.     if err != nil { 
  5.         panic(err) 
  6.     //一般情况下使用这种方式关闭文件 
  7.     defer fileObj.Close() 
  8.  
  9.     //需要将文件对象传进去 
  10.     reader := bufio.NewReader(fileObj) 
  11.     for
  12.         //按行读取 
  13.         row, err := reader.ReadString('\n')//参数是字符,不是字符串 
  14.         if err == io.EOF { 
  15.             break 
  16.         } 
  17.         if err != nil { 
  18.             panic(err) 
  19.         } 
  20.         fmt.Printf("%v",row) 

执行结果

 

读取整个文件

可能又有人说了,啊,星期八,我感觉还是麻烦,有没有更简单的办法读取文件,肯定有呀,一次性读取所有呢?答案是肯定的,此时需要用到ioutil包。

代码

  1. func main() { 
  2.     //os.Open是只读模式 
  3.     bytes, err := ioutil.ReadFile("永不退缩.txt"
  4.     if err != nil { 
  5.         panic(err) 
  6.     fmt.Println(string(bytes)) 

执行结果

 

但是这种有个缺点,只能读取小文件,要是来个10G文件也这样玩,保证电脑死翘翘!!!

写入文件

写入文件的话,我们就需要使用openFile这个方法打开文件

在开始之前呢,先记一下下面几种模式

  • os.O_WRONLY 只写
  • os.O_RDONLY 只读
  • os.O_CREATE 如果文件不存在,则创建文件
  • os.O_RDWR 可读可写
  • os.O_TRUNC 清空
  • os.O_APPEND 追加文件

写入字节和写入行

代码

  1. func main() { 
  2.     fileObj, err := os.OpenFile("临时.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666) 
  3.     if err != nil { 
  4.         panic(err) 
  5.     defer fileObj.Close() 
  6.     w_content := "我是临时表内容\n" 
  7.     //Write方法需要将字符串转成字节 
  8.     fileObj.Write([]byte(w_content)) 
  9.     //WriteString直接写入字符串 
  10.     fileObj.WriteString(w_content) 

执行结果

 

bufio写文件

代码

  1. func main() { 
  2.     fileObj, err := os.OpenFile("临时.txt", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666) 
  3.     if err != nil { 
  4.         panic(err) 
  5.     defer fileObj.Close() 
  6.     w_content := "我是临时表内容\n" 
  7.     writer := bufio.NewWriter(fileObj) 
  8.     writer.Write([]byte(w_content)) 
  9.     writer.WriteString(w_content) 
  10.     //写完必须刷入 
  11.     writer.Flush() 

执行结果

 

ioutil写文件

代码

  1. func main() { 
  2.     w_content := "我是临时表内容\n" 
  3.     err := ioutil.WriteFile("临时.txt", []byte(w_content), 0666) 
  4.     if err != nil { 
  5.         panic(err) 

执行结果

 

拷贝文件

拷贝文件,就是拷贝文件呗,A文件拷贝到B文件中

其实他的底层还是打开俩文件,把A文件内容写入到B文件中

代码

  1. func main() { 
  2.     原文件, err := os.Open("永不退缩.txt"
  3.     if err != nil { 
  4.         panic(err) 
  5.     defer 原文件.Close() 
  6.     目标文件, err := os.OpenFile("临时.txt", os.O_WRONLY|os.O_CREATE, 0666) 
  7.     if err != nil { 
  8.         panic(err) 
  9.     defer 目标文件.Close() 
  10.     //拷贝文件 
  11.     io.Copy(目标文件,原文件) 

执行结果

 

总结

本次章节我们主要学习文件操作的相关知识,主要分为读取文件和写入文件

读取文件都有原生方法读写和bufio加强读写和ioutil一次性读写

推荐大家使用bufio这个包操作文件,带有缓冲功能,性能更好!!

本文转载自微信公众号「Go语言进阶学习」,可以通过以下二维码关注。转载本文请联系Go语言进阶学习公众号。

 

责任编辑:武晓燕 来源: Go语言进阶学习
相关推荐

2021-01-13 08:40:04

Go语言文件操作

2020-11-05 09:58:16

Go语言Map

2020-12-23 08:39:11

Go语言基础技术

2022-02-16 10:03:06

对象接口代码

2020-10-22 08:33:22

Go语言

2020-11-11 10:52:54

Go语言C语言

2020-10-23 08:38:19

Go语言

2020-12-09 09:59:32

Go语言技术

2020-12-30 09:04:32

Go语言TCPUDP

2020-12-27 10:15:44

Go语言channel管道

2020-10-25 07:33:13

Go语言

2022-04-27 10:01:43

切片Go封装

2021-10-09 07:10:31

Go语言基础

2020-12-07 05:59:02

语言Go接口

2021-10-30 10:43:04

语言Go函数

2021-11-03 10:02:07

Go基础函数

2021-02-27 10:20:18

Go语言flag包开发技术

2021-10-16 10:17:51

Go语言数据类型

2020-10-22 11:15:47

Go语言变量

2021-09-29 10:00:07

Go语言基础
点赞
收藏

51CTO技术栈公众号