首页 > 其他分享> > Jochen的goland小抄-进阶篇-File

Jochen的goland小抄-进阶篇-File

2021-02-22 02:01:54 作者：互联网

文件

小抄系列进阶篇涉及的概念较多，知识点重要，故每块知识点独立成篇，方便日后笔记的查询

文件操作是必须要点满的技能，太重要了，开发必定会用到，学就完事

本篇的主题是：文件操作

文件

go语言的文件类（结构体+方法）定义在os包中，在其中封装了底层的文件描述符、文件相关信息和读写文件的方法

如下工程目录下除了示例代码文件外，还有用于测试文件操作的test.txt文件

.
├── file1.go
└── test.txt

#text.txt内容：
goland是世界上最好的语言！

获取文件信息

go语言定义了一个名为FileInfo接口，对外提供了获取文件相关信息的方法

// A FileInfo describes a file and is returned by Stat and Lstat.
type FileInfo interface {
   Name() string       // 文件名.拓展名
   Size() int64        // 文件大小
   Mode() FileMode     // 文件权限 rwxrwxrwx  r->可读 w->可写 x->可执行 从左至右三个一组，分别为文件拥有者 组 其他用户
   ModTime() time.Time // 文件最后一次修改时间
   IsDir() bool        // 是否为文件夹
   Sys() interface{}   // 基础数据源接口 (can return nil)
}

ps：文件权限可以用八进制表示：

r -> 004
w -> 002
x -> 001
- -> 000

go语言给权限设定了很多常量，但是习惯上可以使用二进制数值表示文件的权限如0777

有了接口，那么如何获取实现接口的文件对象呢？

go语言对外暴露的两个获取FileInfo类型对象的方法

func Stat
```
func Stat(name string) (fi FileInfo, err error)
```
Stat返回一个描述name指定的文件对象的FileInfo。如果指定的文件对象是一个符号链接，返回的FileInfo描述该符号链接指向的文件的信息，本函数会尝试跳转该链接。如果出错，返回的错误值为*PathError类型
func Lstat
```
func Lstat(name string) (fi FileInfo, err error)
```
Lstat返回一个描述name指定的文件对象的FileInfo。如果指定的文件对象是一个符号链接，返回的FileInfo描述该符号链接的信息，本函数不会试图跳转该链接。如果出错，返回的错误值为*PathError类型

代码实操：

package main

import (
	"fmt"
	"os"
)

func main() {
	/*
		通过 FileInfo接口 获取文件信息
	*/
	//1.获取文件对象
	fileInfo, err := os.Stat("/home/GoWorkSpace/src/fileTest/test.txt")
	//fileInfo,err := os.Stat("/home/GoWorkSpace/src/fileTest/test1.txt") //不存在的文件
	if err != nil {
		fmt.Println(err) //stat /home/GoWorkSpace/src/fileTest/test1.txt: no such file or directory
		return
	}
	fmt.Printf("%T\n", fileInfo) //*os.fileStat

	//2.获取文件名
	fileName := fileInfo.Name()
	fmt.Printf("%T, %v\n", fileName, fileName) //string, test.txt

	//3.获取文件大小
	fmt.Printf("%T, %v\n", fileInfo.Size(), fileInfo.Size()) //int64, 36

	//4.判断是否为文件夹
	fmt.Printf("%T, %v\n", fileInfo.IsDir(), fileInfo.IsDir()) //bool, false

	//5.获取最后修改时间
	fmt.Printf("%T, %v\n", fileInfo.ModTime(), fileInfo.ModTime()) //bool, false

	//6.获取文件读写权限
	fmt.Printf("%T, %v\n", fileInfo.Mode(), fileInfo.Mode()) //os.FileMode, -rw-r--r--

}

文件路径

获取文件路径的信息和操作定义在path和path/filepath包中

package main

import (
	"fmt"
	"path"
	"path/filepath"
)

func main() {
	/*
		路径：
			相对路径：relative
				text.txt  相对于当前工程
			绝对路径：absolute
				/home/GoWorkSpace/src/fileTest/test1.txt
			. 当前路径
			.. 上一层
	*/
	//1.判断是为绝对路径
	relative := "text.txt"                                 //相对路径
	absolute := "/home/GoWorkSpace/src/fileTest/test1.txt" //绝对路径
	fmt.Println(filepath.IsAbs(relative))                  //false
	fmt.Println(filepath.IsAbs(absolute))                  //true

	//2.获取文件绝对路径（主要是提供相对路径获取绝对路径，绝对路径获取绝对路径意义不大）
	fmt.Println(filepath.Abs(relative)) // /home/GoWorkSpace/src/fileTest/text.txt <nil>

	//3.获取文件的父目录 下面两种方式都可以
	var parentDir = path.Join(absolute, "..")
	fmt.Println(parentDir)                    ///home/GoWorkSpace/src/fileTest
	fmt.Println(path.Dir(absolute))           // /home/GoWorkSpace/src/fileTest
	fmt.Println(path.Dir(path.Dir(absolute))) // /home/GoWorkSpace/src

	//4.获取文件名
	fmt.Println(path.Base(absolute)) //test1.txt

}

File操作

操作文件或目录的函数也定义在os包下

创建文件/文件夹

package main

import (
	"fmt"
	"os"
)

func main() {
	/*
			1.创建文件夹：
				如果文件存在则创建失败
				os.Mkdir()    创建一层文件
				os.MkdirAll() 创建多层文件夹

			2.创建文件
				Create采用666模式(任何人可读写但不可执行)，创建一个指定名称的文件，如果文件一存在会覆盖它(为空文件)
				os.Create() 创建文件,可用相对路径也可以用绝对路径

		ps:注意：Create创建的文件返回的文件对象对应的文件描述符为O_RDONLY模式，即只能进行读操作
	*/

	//1.创建目录
	//1.1、os.Mkdir() 需要传入两个参数：1.创建的文件夹完全名 2.文件夹权限
	err1 := os.Mkdir("/home/GoWorkSpace/src/fileTest/dir", os.ModePerm) //os.ModePerm常量为777
	if err1 != nil {
		fmt.Println(err1) //重复执行报错：mkdir /home/GoWorkSpace/src/fileTest/dir: file exists
	} else {
		fmt.Println("创建成功")
	} //ps:Mkdir只能创建一层文件夹
	//1.2、当想连续创建多层子目录的时候，则需要使用os.MkdirAll()方法，传入参数和上面一致
	err2 := os.MkdirAll("/home/GoWorkSpace/src/fileTest/dir1/dir2/dir", os.ModePerm)
	if err2 != nil {
		fmt.Println(err2) //重复执行报错：mkdir /home/GoWorkSpace/src/fileTest/dir: file exists
	} else {
		fmt.Println("递归创建我目录成功")
	}

	//2.创建文件
	//Create采用666模式(任何人可读写但不可执行)，创建一个指定名称的文件，如果文件一存在会覆盖它(为空文件)
	file1, err3 := os.Create("/home/GoWorkSpace/src/fileTest/test2.txt")
	if err3 != nil {
		fmt.Println(err3) //如果创建的文件路径不存在则报错
		//创建已经存在的同名文件，会覆盖掉旧的文件
	} else {
		fmt.Printf("%T\n", file1) //*os.File 返回的是文件对象指针
		fmt.Println(file1)        //&{0xc000050180}
	}
	//也可以用相对路径创建文件(相对与当前工程)
	file2, err4 := os.Create("test3.txt")
	if err4 != nil {
		fmt.Println(err4)
	} else {
		fmt.Printf("%T\n", file2) //*os.File 返回的是文件对象指针
		fmt.Println(file2)        //&{0xc0000501e0}
	}
	//ps:注意：Create创建的文件返回的文件对象对应的文件描述符为O_RDONLY模式，即只能进行读操作
}

删除文件/文件夹

示例代码延续上面创建的文件和目录

package main

import (
	"fmt"
	"os"
)

func main() {
	/*
		删除文件或文件夹
			os.Remove() 删除空目录或文件
			os.RemoveAll()	删除所有
	*/
	//os.Remove既可以删除文件，也可以删除目录
	//删除文件
	err1 := os.Remove("/home/GoWorkSpace/src/fileTest/test2.txt") //删除一个文件
	if err1 != nil {
		//重复删除报错
		fmt.Println(err1) //remove /home/GoWorkSpace/src/fileTest/test2.txt: no such file or directory
	} else {
		fmt.Println("文件删除成功")
	}

	//删除空目录
	err2 := os.Remove("/home/GoWorkSpace/src/fileTest/dir")
	//err2 := os.Remove("/home/GoWorkSpace/src/fileTest/dir1")
	if err2 != nil {
		//如果 1.目录里面有文件或文件夹  2.目录不存在 则报错
		fmt.Println(err2) //remove /home/GoWorkSpace/src/fileTest/dir1: directory not empty
	} else {
		fmt.Println("目录删除成功")
	}
	//递归删除目录和目录下所有东西
	err3 := os.RemoveAll("/home/GoWorkSpace/src/fileTest/dir1")
	if err3 != nil {
		fmt.Println(err3)

	} else {
		fmt.Println("递归删除目录成功")
	}
}

打开文件

打开文件实际就是上当前程序和指定的文件之间建立一个连接，使得程序可以去愉快的"玩弄"这个文件，例如读写

因为是一个连接，所以要记住，骚操作完后要去关闭连接，节省资源，避免内存泄漏

学习过别的语言的文件操作应该很熟悉，打开一个文件是要提供对应的打开模式的（是只写、只读、可读可写还是追加等等）

对于打开文件的模式，go语言提供了一组常量供我们使用(源码注解还是挺见名知意的，就不全部翻译了)：

const (
   // Exactly one of O_RDONLY, O_WRONLY, or O_RDWR must be specified.
   O_RDONLY int = syscall.O_RDONLY // open the file read-only.
   O_WRONLY int = syscall.O_WRONLY // open the file write-only.
   O_RDWR   int = syscall.O_RDWR   // open the file read-write.
   // The remaining values may be or'ed in to control behavior.
   O_APPEND int = syscall.O_APPEND // append data to the file when writing.
   O_CREATE int = syscall.O_CREAT  // create a new file if none exists.
   O_EXCL   int = syscall.O_EXCL   // 和O_CREATE搭配使用，文件必须不存在
   O_SYNC   int = syscall.O_SYNC   // 打开文件用于同步I/O.
   O_TRUNC  int = syscall.O_TRUNC  // 如果可能，打开时清空文件.
)

还是通过代码示例，看下如果打开文件

package main

import (
	"fmt"
	"os"
)

func main() {
	/*
		1.打开文件:程序和指定文件建立连接
			os.Open()：打开文件，只有读的权限（文件描述符为有O_RDONLY模式）
			os.OpenFile()：指定模式打开文件，需要传入打开文件的模式，可随即应对所有情况
				第一个参数：文件名
				第二个参数：文件的打开方式
				第三个参数：文件的权限，文件不存在则创建文件，该文件需要赋予权限

		2.关闭文件：程序和文件之间断开连接
			file.Close()
	*/

	//1.打开文件
	file1, err1 := os.Open("test.txt") //可以写相对路径也可以使用绝对路径
	if err1 != nil {
		fmt.Println(err1)
	} else {
		fmt.Printf("%T\n", file1) //*os.File 返回的文件对象指针，只有写权限
		fmt.Println(file1)        //&{0xc000104120}
	}
	//指定模式打开文件
	file2, err2 := os.OpenFile("test.txt", os.O_RDONLY|os.O_WRONLY, os.ModePerm) //读写模式打开文件，后面的权限参数主要用于文件不存在时，创建文件后赋予的权限使用
	if err2 != nil {
		fmt.Println(err2)
	} else {
		fmt.Printf("%T\n", file2) //*os.File 返回的文件对象指针，只有写权限
		fmt.Println(file2)        //&{0xc000104180}

	}

	//2.关闭文件：打开文件操作完后记得要去关闭文件，可以通过defer函数统一去关闭所有的文件对象，避免内存泄漏
	defer file1.Close()
	defer file2.Close()

}

文件读写

读写文件即磁盘I/O操作，首先需要认识下什么是I/O

I/O操作

I/O操作即输入输出操作。用于读写数据

输入和输出是相对来说的，如果以程序读写文件或远程网络来说（主体是程序），读取文件或从远程网络获取数据，就是数据输入的过程；如果数据在程序产生要用于持久化到文件或者上传到网络上，就是数据输出的过程

在某些语言中，I/O操作也叫做流操作，指的是数据通信的通道，可以把流理解成是对程序与外界交换数据的一种抽象

go语言的io操作的相关api定义在io包中

io包中只是定义了一系列I/O操作的接口和封装了一些底层实现，具体设备的io操作实现分别定义与各自的包中，如文件的I/O操作（磁盘I/O）即文件的读写操作具体实现就定义在os包下

在io包中，其中有两个最为重要的接口：Reader和Writer接口

Reader接口

Reader接口定义如下：

type Reader interface {
   Read(p []byte) (n int, err error)
}

接口中只定义了Read()方法，其用于读取数据

参数p是byte类型的切片，Read方法读取到的数据就存储到p当中
返回值n表示读取数据的字节数（0<=n<=len(p)）
当Read遇到错误时或 EOF(到达末尾)，返回的err!=nil，n=0
os包下的File结构就提供了I/O操作，其实现了Reader方法，用于读取文件

Writer接口

Writer接口定义如下：

type Writer interface {
   Write(p []byte) (n int, err error)
}

官方文档中关于该接口方法的说明：

Write 将 len(p) 个字节从 p 中写入到基本数据流中。它返回从 p 中被写入的字节数 n（0 <= n <= len(p)）以及任何遇到的引起写入提前停止的错误。若 Write 返回的 n < len(p)，它就必须返回一个非nil 的错误。

实现了Write方法的类型都实现了 io.Writer 接口

Seeker接口

接口定义如下：

type Seeker interface {
    Seek(offset int64, whence int) (ret int64, err error)
}

官方文档中关于该接口方法的说明：

Seek 设置下一次 Read 或 Write 的偏移量为 offset，它的解释取决于 whence： 0 表示相对于文件的起始处，1 表示相对于当前的偏移，而 2 表示相对于其结尾处。 Seek 返回新的偏移量和一个错误，如果有的话。

whence 的值，在 io 包中定义了相应的常量，应该使用这些常量

const (
  SeekStart   = 0 // seek relative to the origin of the file
  SeekCurrent = 1 // seek relative to the current offset
  SeekEnd     = 2 // seek relative to the end
)

读取文件

读取文件是通常通过File类实现的Reader接口中的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)

下面通过示例演示文件的读操作：
有工程目录下有test.txt文件，在其中写着goland是世界上最好的语言！

package main

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

func main() {
	/*
	读取文件：
		Read接口：
			Read(p []byte) (n int, err error)
	*/
	//读取本地test.txt的数据
	//step1：打开文件（获取File对象）
	fileName := "/home/GoWorkSpace/src/fileTest/test.txt"
	file, err := os.Open(fileName) //和本地文件建立连接，可以读写数据了
	if err != nil{
		fmt.Println(err)
		return
	}

	//step3：关闭文件(这第三步在go语言中一般提前使用defer去执行)
	defer file.Close() //断开连接

	//step2：读取数据
	bs := make([]byte,24,24) //Read方法读取到的数据存储在bs字节切片中
	//第一次读取
	n, err2 := file.Read(bs) //n为读取到的字符数，err2为返回的错误
	fmt.Printf("读取的字符数：%d\n",n)
	fmt.Println("错误信息为",err2)
	fmt.Println("读取到的数据为:",bs)
	fmt.Printf("读取到的数据为:%s\n",bs) //以utf8格式现实字符 也可以使用string(bs)进行强转
	/*
	输出：
		读取的字符数：24
		错误信息为 <nil>
		读取到的数据为: [103 111 108 97 110 100 230 152 175 228 184 150 231 149 140 228 184 138 230 156 128 229 165 189]
		读取到的数据为:goland是世界上最好

	*/
	//第二次读取
	n, err3 := file.Read(bs)
	fmt.Printf("读取的字符数：%d\n",n)
	fmt.Println("错误信息为",err3)
	fmt.Println("读取到的数据为:",bs)
	fmt.Printf("读取到的数据为:%s\n",bs) //以utf8格式现实字符 也可以使用string(bs)进行强转
	/*
	输出：
		读取的字符数：12
		错误信息为 <nil>
		读取到的数据为: [231 154 132 232 175 173 232 168 128 239 188 129 231 149 140 228 184 138 230 156 128 229 165 189]
		读取到的数据为:的语言！界上最好

	光标继上一次读取到位置继续往下读取内容
	取实际上读取到 "的语言!" 后，文件已经读取完毕了，后面的字符是之前上一次读取留下的
	即再次读取，如果还有数据未读完，会重新从字节切片的开头填充内容

	*/
	//第三此读取
	n, err4 := file.Read(bs)
	fmt.Printf("读取的字符数：%d\n",n)
	fmt.Println("错误信息为",err4)
	fmt.Println("读取到的数据为:",bs)
	fmt.Println("读取到的数据为:",string(bs))
	/*
	输出：
		读取的字符数：0
		错误信息为 EOF
		读取到的数据为: [231 154 132 232 175 173 232 168 128 239 188 129 231 149 140 228 184 138 230 156 128 229 165 189]
		读取到的数据为:的语言！界上最好
	上一次已经读取完所以内容，再次调用读取方法，err返回EOF,读取的字符数为0

	*/

	//平时写也不会那么呆瓜一次一次的自己去读取，而是通过循环，判断err是否到达末尾作为终止条件
	//下面是一般的标准写法
	println("--------------------------------")
	file2, err := os.Open(fileName)
	defer file2.Close()
	bs2 := make([]byte,1024,1024) //字节数组作为读取缓冲区，一般设置为1024
	n1 := -1 //返回读取的数量，输出化为-1
	for {
		n1,err = file2.Read(bs2)
		if n1 == 0 || err == io.EOF {
			fmt.Println("读取到了文件的末尾，结束读取操作")
			break
		}
		fmt.Println(string(bs2[:n1]))  //打印的数据应该是读取了多少打印了多少
	}
	/*
	输出：
		goland是世界上最好的语言！
		读取到了文件的末尾，结束读取操作
	*/

	//除了Read方法读取，还有ReaderAt和ReaderFrom
	//ReaderAt方法用于指定位置去读取（Reader是从头开始读）
	fmt.Println(file.ReadAt(bs,2)) //从第二个字节（不是字符）位置开始读
	fmt.Println(string(bs)) //land是世界上最好�

	//ReaderFrom() 从io对象读取数据
	//下面的例子简单的实现将文件中的数据全部读取（显示在标准输出）：
	writer := bufio.NewWriter(os.Stdout)
	writer.ReadFrom(file)
	writer.Flush()
	/*
		ReadFrom 从 r 中读取数据，直到 EOF 或发生错误。
		其返回值 n 为读取的字节数。除 io.EOF 之外，在读取过程中遇到的任何错误也将被返回。

		我们可以通过 ioutil 包的 ReadFile 函数获取文件全部内容。
		其实，跟踪一下 ioutil.ReadFile 的源码，会发现其实也是通过 ReadFrom 方法实现（用的是 bytes.Buffer，它实现了 ReaderFrom 接口）
	
		如果不通过 ReadFrom 接口来做这件事，而是使用 io.Reader 接口，我们有两种思路：
			1.先获取文件的大小（File 的 Stat 方法），之后定义一个该大小的 []byte，通过 Read 一次性读取
			2.定义一个小的 []byte，不断的调用 Read 方法直到遇到 EOF，将所有读取到的 []byte 连接到一起


	*/
}

写文件

读取文件通常是通过File类实现的Writer接口中的Write方法而实现，其定义如下：

// Write writes len(b) bytes to the File.
// It returns the number of bytes written and an error, if any.
// Write returns a non-nil error when n != len(b).
func (f *File) Write(b []byte) (n int, err error) {
   if err := f.checkValid("write"); err != nil {
      return 0, err
   }
   n, e := f.write(b)
   if n < 0 {
      n = 0
   }
   if n != len(b) {
      err = io.ErrShortWrite
   }

   epipecheck(f, e)

   if e != nil {
      err = f.wrapErr("write", e)
   }

   return n, err
}

还是通过代码示例直观演示：
在工程目录下创建writeFile.txt文件

package main

import (
	"fmt"
	"os"
)

func main() {
	/*
		写文件
	*/

	fileName := "/home/GoWorkSpace/src/fileTest/writeFile.txt" 	//所要写文件的fullName

	//step1：打开文件
	//file, err := os.Open(fileName) //Open只能通过只读的方式打开文件，不能实现文件不存在时创建文件
	file, err := os.OpenFile(fileName,os.O_RDWR|os.O_CREATE,os.ModePerm)
	if err != nil{
		fmt.Println(err)
		return
	}

	//step3：关闭文件
	defer file.Close()

	//step2：写数据
	//写数据，会覆盖原有的数据，因为我们是通过O_RDWR模式打开的文件，如果想追加末尾写数据需要使用O_APPEND模式打开
	bs := []byte{'J','o','c','h','e','n','\n'} //byte<->uint8
	n,err := file.Write(bs)
	fmt.Printf("写进文件%d个字节\n",n)
	fmt.Println(err)

	//获取文件的字节数量，创建相应大小的缓冲区，一次性读取
	info,_ := file.Stat()
	rbs := make([]byte,info.Size(),info.Size())
	rn, rerr := file.ReadAt(rbs,0) //写入数据光标会停留在文件末尾，所以使用ReadAt方法指定光标位置读取
	fmt.Println("读取的字节数为：",rn)
	fmt.Println(rerr)
	fmt.Println("读取的数据为：",string(rbs))

	//写文件除了Write方法
	//1.还可以使用StringWriter接口定义的WriteString方法该方法可以直接写入字符串，不用搞上面的字节切片那么麻烦
	n2, err2 := file.WriteString("写的好爽啊哈哈哈\n")
	fmt.Println(n2)
	fmt.Println(err2)
	//用write写直接写字符串也可以，因为字符串是可以转成字节切片的
	n3, err3 := file.Write([]byte("写的也还算舒服\n"))
	fmt.Println(n3)
	fmt.Println(err3)

	//2.还可以使用WriteAt方法，作用和ReadAt一毛一样，就是指定光标位置去写
	n4, err4 := file.WriteAt([]byte("指定位置写\n"),0) //重头开始写
	fmt.Println(n4)
	fmt.Println(err4)

}

本系列学习资料参考：
https://www.bilibili.com/video/BV1jJ411c7s3?p=15
https://books.studygolang.com/The-Golang-Standard-Library-by-Example/chapter01/01.1.html

标签：文件,读取,err,fmt,小抄,进阶篇,goland,Println,os
来源： https://www.cnblogs.com/deehuang/p/14428158.html