Go_文件操作

从春到秋冬

已于 2023-03-15 14:50:18 修改

阅读量175

点赞数

分类专栏： Golang学习文章标签： golang 开发语言后端

于 2023-03-15 14:49:49 首次发布

本文链接：https://blog.csdn.net/tai_yang_yue/article/details/129484840

版权

Golang学习专栏收录该内容

18 篇文章 0 订阅

订阅专栏

文件操作

文件在程序中是以流的形式来操作的
os.File封装了所有文件相关的操作，File是一个结构体

常用的文件操作函数和方法

打开文件：func Open(name string) (file *File, err error)
name：写文件的路径
关闭文件：func (f *File) Close() error
案例演示

package main
import(
	"fmt"
	"os"
)
/*
概念说明：file的叫法
1、file叫file对象
2、file叫file指针
3、file叫file文件句柄
*/
func main(){
	//打开文件
	file, err := os.Open("D:/学习之路/Go语言/test100.txt")
	if err != nil{
		fmt.Println("open file err=", err)
	}
	//输出文件内容，file就是一个 *File
	fmt.Printf("file=%v", file)

	//关闭文件
	err = file.Close()
	if err != nil{
		fmt.Println("close file err=", err)
	}

}

读取文件的内容并显示在终端（带缓冲区的方式），使用os.Open、file.Close、bufio.NewReader()、reader.ReadString函数和方法

package main
import(
	"fmt"
	"os"
	"io"
	"bufio"
)
/*
概念说明：file的叫法
1、file叫file对象
2、file叫file指针
3、file叫file文件句柄
*/
func main(){
	//打开文件
	file, err := os.Open("D:/学习之路/Go语言/test100.txt")
	if err != nil{
		fmt.Println("open file err=", err)
	}
	//输出文件内容，file就是一个 *File
	fmt.Printf("file=%v\n", file)

	//关闭文件
	defer file.Close()//要及时关闭file句柄，否则会有内存泄露
	//创建一个 *Reader ，带缓冲的
	/*
	const(
		defaultBufsize = 4096//默认缓冲区4096
	)
	*/

	reader := bufio.NewReader(file)
	//循环读取文件的内容
	for{
		str, err := reader.ReadString('\n')//读到一个换行就结束
		if err == io.EOF{//io.EOF表示文件的末尾
			break
		}
		//输出内容
		fmt.Print(str)
	}
	fmt.Println("文件读取结束...")

}

读取文件内容并显示在终端（使用ioutil 一次将整个文件读入到内存中），适用于文件不大的情况
- 方法和函数 ioutil.ReadFile（func ReadFile(filename string) ([]byte, error)）

package main
import(
	"fmt"
	"io/ioutil"
)
/*
概念说明：file的叫法
1、file叫file对象
2、file叫file指针
3、file叫file文件句柄
*/
func main(){
	//因为没有显示的open文件，也不需要显示的close文件
	//因为文件的open和close被封装到ReadFile内部
	str, err := ioutil.ReadFile("D:/学习之路/Go语言/test100.txt")
	if err != nil{
		fmt.Println("open file err=", err)
	}
	//输出内容
	fmt.Printf("%v\n", str)//输出[]byte
	//要输出具体内容，需要转成string
	fmt.Printf("%v", string(str))
}

写文件os.OpenFile()：func OpenFile(name string, flag int, perm FileMode) (file *File, err error)
- name：文件名
- flag :文件打开的模式
- perm：权限控制（Linux\Unix下面有用）

1、
package main
import(
	"fmt"
	"os"
	"bufio"
)
func main(){
	filepath := "D:/学习之路/Go语言/test200.txt"
	file, err := os.OpenFile(filepath, os.O_WRONLY | os.O_CREATE, 0666)
	if err!= nil{
		fmt.Printf("open file err=%v\n", err)
		return
	}
	//关闭文件
	defer file.Close()
	//准备写入的字串
	str := "hello, Gardon\n"
	writer := bufio.NewWriter(file)
	//写入时，使用带缓存的writer
	for i:=0; i<5;i++{
		writer.WriteString(str)
	}
	/*因为writer是带缓存的，因此在调用writerstring方法时，
	内容先写入到缓存中，所以需要调用Flush方法，
	将缓存的数据真正写入到文件中，否则文件中会没有数据*/
	writer.Flush()
}

2、

package main
import(
	"fmt"
	"os"
	"bufio"
)
func main(){
	filepath := "D:/学习之路/Go语言/test200.txt"
	file, err := os.OpenFile(filepath, os.O_WRONLY | os.O_TRUNC, 0666)
	if err!= nil{
		fmt.Printf("open file err=%v\n", err)
		return
	}
	//关闭文件
	defer file.Close()
	//准备写入的字串
	str := "hello, 中国\n"
	writer := bufio.NewWriter(file)
	//写入时，使用带缓存的writer
	for i:=0; i<10;i++{
		writer.WriteString(str)
	}
	/*因为writer是带缓存的，因此在调用writerstring方法时，
	内容先写入到缓存中，所以需要调用Flush方法，
	将缓存的数据真正写入到文件中，否则文件中会没有数据*/
	writer.Flush()
}

3、

package main
import(
	"fmt"
	"os"
	"bufio"
)
func main(){
	filepath := "D:/学习之路/Go语言/test100.txt"
	file, err := os.OpenFile(filepath, os.O_WRONLY | os.O_APPEND, 0666)
	if err!= nil{
		fmt.Printf("open file err=%v\n", err)
		return
	}
	//关闭文件
	defer file.Close()
	//准备写入的字串
	str := "hello, 中国\n"
	writer := bufio.NewWriter(file)
	//写入时，使用带缓存的writer
	for i:=0; i<3;i++{
		writer.WriteString(str)
	}
	/*因为writer是带缓存的，因此在调用writerstring方法时，
	内容先写入到缓存中，所以需要调用Flush方法，
	将缓存的数据真正写入到文件中，否则文件中会没有数据*/
	writer.Flush()
}


4、
package main
import(
	"fmt"
	"os"
	"bufio"
	"io"
)
func main(){
	filepath := "D:/学习之路/Go语言/test100.txt"
	file, err := os.OpenFile(filepath, os.O_RDWR | os.O_APPEND, 0666)
	if err!= nil{
		fmt.Printf("open file err=%v\n", err)
		return
	}
	//关闭文件
	defer file.Close()
	//先读取原来的文件内容，并显示在终端
	reader := bufio.NewReader(file)
	for {
		str, err := reader.ReadString('\n')
		if err == io.EOF{
			break
		}
		fmt.Print(str)
	}
	//准备写入的字串

	str := "\nhello, 北京"
	writer := bufio.NewWriter(file)
	//写入时，使用带缓存的writer
	for i:=0; i<5;i++{
		writer.WriteString(str)
	}
	/*因为writer是带缓存的，因此在调用writerstring方法时，
	内容先写入到缓存中，所以需要调用Flush方法，
	将缓存的数据真正写入到文件中，否则文件中会没有数据*/
	writer.Flush()
}

在这里插入图片描述

package main
import(
	"fmt"
	"io/ioutil"
)
//将文件test100中的内容导入到文件test200
/*将文件test100中的内容读取到内存
将读取到的内存追加到文件test200*/
func main(){
	filepath01 := "D:/学习之路/Go语言/test200.txt"
	filepath02 := "D:/学习之路/Go语言/test100.txt"
	count, err := ioutil.ReadFile(filepath01)
	if err != nil{
		fmt.Printf("read file01 err=%v\n", err)
		return
	}
	err = ioutil.WriteFile(filepath02, count, 0666)
	if err != nil{
		fmt.Printf("write file02 err=%v\n", err)
	}

}

判断文件是否存在
path：文件路径；根据bool值，true表明文件存在，false表明文件不存在
拷贝文件

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

func FileCopy(dstFileName string, srcFileName string) (written int64, err error){
	srcFile, err := os.Open(srcFileName)
	if err != nil{
		fmt.Println("open file err = %v\n", err)
	}
	defer srcFile.Close()
	reader := bufio.NewReader(srcFile)

	dstFile, err := os.OpenFile(dstFileName, os.O_WRONLY | os.O_CREATE, 0666)
	if err != nil{
		fmt.Println("open file err = %v\n", err)
	}
	defer dstFile.Close()
	writer := bufio.NewWriter(dstFile)

	return io.Copy(writer, reader)
}
func main(){
	//将 D:/图片集/框图三.jpg 文件拷贝到 D:/学习之路/Go语言/abc.jpg
	srcFile := "D:/图片集/框图三.jpg"
	dstFile := "D:/学习之路/Go语言/abc.jpg"
	_, err := FileCopy(dstFile, srcFile)
	if err != nil{
		fmt.Printf("拷贝失败，err=%v\n", err)
	}else{
		fmt.Printf("拷贝成功")
	}
}

统计英文、数字、空格和其他字符数量（统计一个文件中含有的英文、数字、空格及其他字符数量）

package main
import (
	"fmt"
	"io"
	"bufio"
	"os"
)
//定义一个结构体，用于保存统计结果
type CharCount struct{
	ChCount int  //记录英文个数
	NumCount int  //记录数字的个数
	SpaceCount int  //记录空格的个数
	OtherCount int  //记录其他的个数
}

//思路：打开一个文件，创建一个reader；
func main(){
	//声明结构体实例
	var count CharCount
	filename := "D:/学习之路/Go语言/test300.txt"
	file, err := os.Open(filename)
	if err != nil{
		fmt.Printf("open file err=%v\n", err)
		return
	}
	defer file.Close()
	reader := bufio.NewReader(file)
	//开始循环读取filename中的内容
	for{
		str, err := reader.ReadString('\n')
		if err == io.EOF{//读到文件末尾就退出
			break
		}
		//遍历str，为了兼容中文字符，可将str转成[]rune，即 str = []rune(str)
		for _, v := range str{
			switch{
			case v >= 'a' && v <= 'z':
				fallthrough   //穿透
			case v >= 'A' && v <= 'Z':
				count.ChCount++
			case v ==' ' || v =='\t':
				count.SpaceCount++
			case v >= '0' && v <='9':
				count.NumCount++
			default:
				count.OtherCount++
			}
		}
	}
	fmt.Printf("字符的个数为：%v，数字的个数为：%v，空格的个数为：%v，其他字符为：%v\n", count.ChCount, count.NumCount, count.SpaceCount,count.OtherCount)
}