当前位置：首页 > news >正文

go中的文件、目录的操作

news 来源：原创 2025/4/27 18:34:34

1.文件的概念

文件是数据源（保存数据的地方）的一种，比如大家经常使用的word文档，txt文件，excel文件等。文件最主要的作用就是保存数据，它既可以保存一张图片，也可以保存视频，声音等。

文件在程序中以流的形式来操作的。

流：数据在数据源（文件）和程序（内存）之间经历的路径
输入流：数据从数据源（文件）到程序（内存）的路径
输出流：数据从程序（内存）到数据源（文件）路径

2.读取文件

2.1读取文件方式一

1.只读的方式打开文件，file,err:=os.Open()

func Open(name string) (*File, error) {
	return OpenFile(name, O_RDONLY, 0)
}

Open打开一个文件用于读取。如果操作成功，返回的文件对象的方法可用于读取数据；对应的文件描述具有O_RDONLY（只读模式）。

2.读取文件file.read()

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

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

3.关闭文件流 defer file.Close()

2.1.1案例一

func ReadFile1(path string) {
	//	1.只读方式打开文件
	file, err := os.Open(path)
	if err != nil {
		fmt.Println("文件打开失败！")
	}
	//	2.读取文件
	tem := make([]byte, 128)
	n, err := file.Read(tem)
	fmt.Printf("读取了%v的字节\n", n)
	fmt.Println(string(tem[:n]))
	//	关闭文件流
	defer file.Close()
}
func main() {
	ReadFile1("D:/test.txt")
}

结果：

读取了128的字节
寻寻觅觅，冷冷清清，凄凄惨惨戚戚。
乍暖还寒时候，最难将息。
三杯两盏淡酒，怎敌他、晚�

2.1.2案例二（循环读取）

func ReadFile2(path string) {
	//	1.只读方式打开文件
	file, err := os.Open(path)
	if err != nil {
		fmt.Println("文件打开失败！")
	}
	//	2.读取文件
	var fileSilce []byte
	tem := make([]byte, 128)
	for {
		n, err := file.Read(tem)
		if err == io.EOF {
			fmt.Println("读取完毕")
			break
		}
		if err != nil {
			fmt.Println(err.Error())
		}
		fileSilce = append(fileSilce, tem[:n]...)
	}

	fmt.Println(string(fileSilce))
	//	关闭文件流
	defer file.Close()
}
func main() {
	ReadFile2("D:/test.txt")

}

结果：

读取完毕
寻寻觅觅，冷冷清清，凄凄惨惨戚戚。
乍暖还寒时候，最难将息。
三杯两盏淡酒，怎敌他、晚来风急？
雁过也，正伤心，却是旧时相识。

满地黄花堆积。
憔悴损，如今有谁堪摘？
守著窗儿，独自怎生得黑？
梧桐更兼细雨，到黄昏、点点滴滴。
这次第，怎一个愁字了得！

2.1.3总结

不论循环读取还是读取一次都是把读取到的内容放到一个[]byte中，就像泳池排水，单位时间内的排水量。读取一次就是泳池完成一个单位时间的排水量，循环读取读取就是用多个单位时间排水，知道清空泳池。

2.2读取文件的方式二（bufio读取文件）

2.2.1bufio读取文件

只读方式打开文件file,err:=os.Open()
创建reader对象 reader := bufio.NewReader(file)
ReadString读取文件 str, err := reader.ReadString('\n')
关闭文件流 defer file.Close()

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

2.2.2案例

func ReadFile4(path string) {
	file, err := os.Open(path)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	reader := bufio.NewReader(file)
	var content = ""
	for {
		str, err := reader.ReadString('\n')//一次读取一行数据，注意是字符
		if err == io.EOF {
			if len(str) > 0 {
				content += str
			}
			break
		}
		if err != nil {
			fmt.Println(err.Error())
			return
		}
		content += str
	}

	fmt.Println(content)
}
func main() {
	ReadFile4("D:/test.txt")
}

2.3读取文件方式三（ioutil读取整个文件）

注意：打开关闭文件的方法它都封装好了只需要一句话就可以读取。

func ReadFile5(path string) {
	by, err := ioutil.ReadFile(path)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println(string(by))
}

3.文件的写入操作

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

func OpenFile(name string, flag int, perm FileMode) (*File, error)

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

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

3.1Write和WriteString写入

1.打开文件 file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)

2.写入文件 file.Write([]byte("写入操作测试\r\n"))
file.WriteString("写入操作测试\r\n")

3.关闭文件流 defer file.Close()

func WriterFile(path string) {
	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
	defer file.Close()
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	file.Write([]byte("写入操作测试\r\n"))
	file.WriteString("写入操作测试\r\n")
}

3.2bufio.NewWriter写

1.打开文件 file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)

2.创建writer对象 writer := bufio.NewWriter(file)

3.将数据先写入缓存 writer.WriteString("我是一个函数" + "\r\n")

4.将缓存中的内容写入文件 writer.Flush()

5.关闭文件流 defer file.Close()

func WriteFile2(path string) {
	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)
	defer file.Close()
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	writer := bufio.NewWriter(file)
	for i := 0; i < 11; i++ {
		writer.WriteString("我是一个函数" + "\r\n")
	}
	writer.Flush()

}

3.3ioutil.WriteFile写

func WriterFile3(path string) {
	ioutil.WriteFile(path, []byte("hello word !"), 0666)
}

4.目录操作

4.1文件重命名

func main() {
	err := os.Rename("D:/test.txt", "D:/test1.txt") //只能同盘操作
	if err != nil {
		fmt.Println(err)
	}
}

4.2复制值文件

4.2.1ioutil进行复制

func main() {
	by, err := ioutil.ReadFile("D:/test.txt")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	err = ioutil.WriteFile("D:/copytest.txt", by, 0666)
	if err != nil {
		fmt.Println(err.Error())

	}
}

4.2.2复制文件方法流的方式复制

func main() {
	//获取输入流对象
	file, err := os.Open("D:/test.txt")
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	reader := bufio.NewReader(file)
	defer file.Close()
	//	获取输出流对象
	wfile, err := os.OpenFile("D:/copy.txt", os.O_CREATE|os.O_APPEND, 0666)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	writer := bufio.NewWriter(wfile)
	defer wfile.Close()
	//	复制文件
	for {
		line, err := reader.ReadString('\n')
		if err == io.EOF {
			if len(line) > 0 {
				writer.WriteString(line)
			}

			break
		}

		if err != nil {
			fmt.Println(err.Error())
			break
		}
		writer.WriteString(line)

	}
	writer.Flush()
}

4.3创建目录

func main() {

	err := os.Mkdir("./abc", 0666) //一次创建一个一个目录
	if err != nil {
		fmt.Println(err)
	}

	err = os.MkdirAll("dir1/dir2/dir3", 0666) //创建多级目录
	if err != nil {
		fmt.Println(err)
	}
}

4.4删除目录和文件

func main() {
	//删除一个目录或者文件
	err := os.Remove("aaa.txt")
	if err != nil {
		fmt.Println(err)
	}
	//一次删除多个目录或者文件
	err = os.RemoveAll("dir1")
	if err != nil {
		fmt.Println(err)
	}
}