Golang 文件操作

最新推荐文章于 2024-05-22 14:02:44 发布
最新推荐文章于 2024-05-22 14:02:44 发布
阅读量770 收藏 1
点赞数 2
分类专栏： Golang 文章标签： tar gzip zip os file
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/elihe2011/article/details/124472104
版权

1. 读文件

  • os.Open(name string) (file *File, err error)
  • os.OpenFile(name string, flag int, perm FileMode) (*File, error)
  • ioutil.ReadFile(name string) ([]byte, error)

1.1 带缓存读

func main() {
	file, err := os.Open("./abc.txt")
	if err != nil {
		fmt.Printf("Open file error: %v\n", err)
		return
	}
	defer file.Close()

	reader := bufio.NewReader(file)
	for {
		// 按行读取
		line, err := reader.ReadString('\n')
		if err == io.EOF {
			break
		}
		fmt.Print(line)
	}
}

1.2 一次性读

适合配置文件等小文件

func main() {
	bs, err := ioutil.ReadFile("./abc.txt")
	if err != nil {
		fmt.Printf("Read file error: %v\n", err)
		return
	}

	fmt.Printf("%s\n", bs)
}

1.3 分片读取

func main() {
	file, err := os.Open("abc.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	for {
		buf := make([]byte, 32)
		_, err = file.Read(buf)
		if err == io.EOF {
			break
		}

		if err != nil {
			panic(err)
		}

		fmt.Printf("%s", buf)
	}
}

1.4 寻址 seek

寻址标记 whence: 0-begin, 1-current, 2-end

file, _ := os.Open("abc.txt")
	defer file.Close()

	// 开始位置前进5个字节
	var whence = 0
	var offset int64 = 5
	pos, _ := file.Seek(offset, whence)
	fmt.Println("Jump forward 5 bytes from start position:", pos)

	// 当前位置回退2个字节
	whence = 1
	offset = -2
	pos, _ = file.Seek(offset, whence)
	fmt.Println("Jump back 2 bytes from current position:", pos)
}

1.5 分隔符读取

  • bufio.NewScanner(r io.Reader) *Scanner
func main() {
	file, _ := os.Open("abc.txt")
	defer file.Close()

	scanner := bufio.NewScanner(file)

	// 分隔函数，默认 bufio.ScanLines
	scanner.Split(bufio.ScanWords)

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}

	err := scanner.Err()
	if err != nil {
		panic(err)
	}
}

1.6 按行读取

func main() {
	file, err := os.Open("abc.txt")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	// 放入缓冲读
	reader := bufio.NewReader(file)

	for {
		// 自动丢失结尾符 \n
		line, _, err := reader.ReadLine()
		if err == io.EOF {
			break
		}
		if err != nil {
			panic(err)
		}

		fmt.Printf("%s\n", line)
	}
}

2. 写文件

  • os.OpenFile(name string, flag int, perm FileMode) (file *File, err error)
  • os.Create(name string) (*File, error)
  • io/ioutil.Write(filename string, data []byte, perm fs.FileMode) error

文件操作模式：

  • 覆盖写：os.O_WRONLY | os.O_TRUNC
  • 追加写：os.O_WRONLY | os.O_APPEND
  • 读写并追加：os.O_RDWR | os.OS_APPEND

2.1. 常规写

func writeFile() {
	file, err := os.OpenFile("abc.txt", os.O_CREATE|os.O_APPEND|os.O_RDWR, 0644)
	if err != nil {
		panic(err)
	}
	defer file.Close()

	byteSlice := []byte("hello world!")
	bytesWritten, err := file.Write(byteSlice)
	if err != nil {
		panic(err)
	}
	fmt.Printf("Wrote %d bytes\n", bytesWritten)
}

2.2 快速写

覆盖写：

func main() {
	err := ioutil.WriteFile("abc.txt", []byte("add a new line"), 0644)
	if err != nil {
		panic(err)
	}
}

2.3 缓冲写

bufio 包:

func NewWriter(w io.Writer) *Writer
func NewWriterSize(w io.Writer, size int) *Writer

func (b *Writer) Write(p []byte) (nn int, err error)
func (b *Writer) WriteString(s string) (int, error)
func (b *Writer) WriteByte(c byte) error
func (b *Writer) WriteRune(r rune) (size int, err error)

func (b *Writer) Flush() error

func bufferedWrite() {
	file, err := os.OpenFile("abc.txt", os.O_WRONLY, 0644)
	if err != nil {
		panic(err)
	}
	defer file.Close()

	// 缓冲写
	bufferedWriter := bufio.NewWriter(file)

	// 写入字节
	bytesWritten, err := bufferedWriter.Write([]byte{65, 66, 47, '\n'})
	if err != nil {
		panic(err)
	}
	fmt.Printf("Bytes written: %d\n", bytesWritten)

	// 写入字符串
	bytesWritten, err = bufferedWriter.WriteString("Buffered string\n")
	if err != nil {
		panic(err)
	}
	fmt.Printf("Bytes written: %d\n", bytesWritten)

	// 缓冲中的字节数
	unflushedBufferSize := bufferedWriter.Buffered()
	fmt.Printf("Bytes buffered: %d\n", unflushedBufferSize)

	// 未使用缓存的大小
	bytesAvailable := bufferedWriter.Available()
	fmt.Printf("Available buffer: %d\n", bytesAvailable)

	// 写入磁盘
	bufferedWriter.Flush()

	// 重置缓存写，将丢弃缓存内容
	bufferedWriter.Reset(bufferedWriter)

	bytesAvailable = bufferedWriter.Available()
	fmt.Printf("Available buffer after reset: %d\n", bytesAvailable)

	// 重置缓存大小
	bufferedWriter = bufio.NewWriterSize(bufferedWriter, 8000)

	// 重置后的缓存大小
	bytesAvailable = bufferedWriter.Available()
	fmt.Printf("Available buffer after set buffered size: %d\n", bytesAvailable)
}

简单：

func main() {
	file, err := os.OpenFile("abc.txt", os.O_CREATE|os.O_WRONLY, 0600)
	if err != nil {
        panic(err)
	}
	defer file.Close()

	msg := "Hello World!\n"

	writer := bufio.NewWriter(file)
	for i := 0; i < 5; i++ {
		writer.Write([]byte(msg))
	}
	writer.Flush()
}

3. 拷贝文件

3.1 直接拷贝

适合小文件、文本文件

func main() {
	bs, err := ioutil.ReadFile("abc.txt")
	if err != nil {
        panic(err)
	}

	err = ioutil.WriteFile("abc.txt", bs, 0600)
	if err != nil {
		 panic(err)
	}
}

3.2 缓冲拷贝

io 包，适合大文件、二进制文件：

// 默认缓冲区大小
func Copy(dst Writer, src Reader) (written int64, err error)

// 自定义缓冲区大小
func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)

func CopyFile(dstFileName, srcFileName string) (written int64, err error) {
	srcFile, err := os.OpenFile(srcFileName, os.O_RDONLY, 0)
	if err != nil {
		return 0, err
	}
	defer srcFile.Close()

	dstFile, err := os.OpenFile(dstFileName, os.O_CREATE|os.O_WRONLY, 0600)
	if err != nil {
		return 0, err
	}
	defer dstFile.Close()

	writer := bufio.NewWriter(dstFile)
	reader := bufio.NewReader(srcFile)

	written, err = io.Copy(writer, reader)
    
    // flush to disk
	err = writer.Sync()
	if err != nil {
		return 0, err
	}

	return
}

4. 统计文件

4.1 文件信息

func statFile() {
	fileInfo, err := os.Stat("abc.txt")
	if err != nil {
        // 判断文件是否存在
		if os.IsNotExist(err) {
			fmt.Println("file not exist")
		}
		panic(err)
	}

	fmt.Println("File name:", fileInfo.Name())
	fmt.Println("Size in bytes:", fileInfo.Size())
	fmt.Println("Permissions:", fileInfo.Mode())
	fmt.Println("Last modified:", fileInfo.ModTime())
	fmt.Println("Is directory:", fileInfo.IsDir())
	fmt.Printf("System interface type: %T\n", fileInfo.Sys())
	fmt.Printf("System info: %+v\n", fileInfo.Sys())
}

4.1 字符统计

type Statistic struct {
	Char   int
	Number int
	Space  int
	Other  int
}

func main() {
	file, err := os.Open("./abc.txt")
	if err != nil {
		fmt.Printf("Open file error: %v\n", err)
		return
	}
	defer file.Close()

	stat := Statistic{}

	reader := bufio.NewReader(file)
	for {
		bs, err := reader.ReadString('\n')
		if err == io.EOF {
			break
		}

		for _, c := range []rune(bs) {
			switch {
			case c >= 'a' && c <= 'z':
				fallthrough
			case c >= 'A' && c <= 'Z':
				stat.Char++
			case c >= '0' && c <= '9':
				stat.Number++
			case c == ' ' || c == '\t':
				stat.Space++
			default:
				stat.Other++
			}
		}
	}

	fmt.Printf("%v\n", stat)
}

5. 目录遍历

filepath 包:

  • type WalkFunc func(path string, info os.FileInfo, err error) error
  • func Walk(root string, walkFn WalkFunc) error
func main() {
	err := filepath.Walk("/tmp", walkFunc)
	if err != nil {
		panic(err)
	}
}

func walkFunc(path string, info fs.FileInfo, err error) error {
	fmt.Println(path)

	return nil
}

7. 压缩文件

7.1 zip

7.1.1 压缩

func zipCompress() {
	target := "/var/log"
	zipFilename := fmt.Sprintf("%s.zip", filepath.Base(target))

	// 压缩文件
	writer, err := os.Create(zipFilename)
	if err != nil {
		log.Fatal(err)
	}
	defer writer.Close()

	err = CompressZip(target, writer)
	if err != nil {
		log.Fatal(err)
	}
}

func CompressZip(rootDir string, writer io.Writer) (err error) {
	// writer
	zipWriter := zip.NewWriter(writer)
	defer zipWriter.Close()

	// 遍历写入文件
	err = filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		// 压缩包头信息
		header, err := zip.FileInfoHeader(info)
		if err != nil {
			return err
		}

		// 文件名，去除最外层的
		header.Name = strings.TrimPrefix(path, filepath.Dir(rootDir))
		if info.IsDir() {
			header.Name += "/"
		}

		// 普通文件，进行压缩
		if info.Mode().IsRegular() {
			header.Method = zip.Deflate
		}

		// 创建压缩包头信息
		fileWriter, err := zipWriter.CreateHeader(header)
		if err != nil {
			return err
		}

		// 非文件，直接返回
		if !info.Mode().IsRegular() {
			return nil
		}

		// 打开待压缩的文件
		reader, err := os.Open(path)
		if err != nil {
			return err
		}
		defer reader.Close()

		// 写入文件
		_, err = io.Copy(fileWriter, reader)

		return err
	})

	return
}

7.1.2 解压

func zipExtract() {
	zipFilename := `C:\Users\MSN\Downloads\log.zip`

	// 解压文件
	err := ExtractZip(zipFilename)
	if err != nil {
		log.Fatal(err)
	}
}


func ExtractZip(zipFilename string) error {
	baseDir := filepath.Dir(zipFilename)

	zipReader, err := zip.OpenReader(zipFilename)
	if err != nil {
		return err
	}
	defer zipReader.Close()

	for _, file := range zipReader.Reader.File {
		err = func(file *zip.File) error {
			zippedFile, err := file.Open()
			if err != nil {
				return err
			}
			defer zippedFile.Close()

			extractedFilePath := filepath.Join(baseDir, file.Name)

			if file.FileInfo().IsDir() {
				err = os.MkdirAll(extractedFilePath, file.Mode())
				if err != nil {
					return err
				}
			} else if file.FileInfo().Mode().IsRegular() {
				outputFile, err := os.OpenFile(extractedFilePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, file.Mode())
				if err != nil {
					return err
				}
				defer outputFile.Close()

				_, err = io.Copy(outputFile, zippedFile)
				if err != nil {
					return err
				}
			} else {
				log.Printf("unknown type: %c in %s\n", file.Mode().Type(), file.Name)
			}

			return nil
		}(file)

		if err != nil {
			return err
		}
	}

	return nil
}

7.2 tar & gzip

7.2.1 压缩

func tgzCompress() {
	target := "/var/log"
	tgzFilename := fmt.Sprintf("%s.tar.gz", filepath.Base(target))

	// 压缩文件
	writer, err := os.Create(tgzFilename)
	if err != nil {
		log.Fatal(err)
	}
	defer writer.Close()

	err = CompressTarGz(target, writer)
	if err != nil {
		log.Fatal(err)
	}
}

func CompressTarGz(rootDir string, writer io.Writer) (err error) {
	gzipWriter := gzip.NewWriter(writer)
	defer gzipWriter.Close()

	tarWriter := tar.NewWriter(gzipWriter)
	defer tarWriter.Close()

	// 遍历写入文件
	err = filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		var link string
		if info.Mode()&os.ModeSymlink == os.ModeSymlink {
			if link, err = os.Readlink(path); err != nil {
				return err
			}
		}

		// 压缩包头信息
		header, err := tar.FileInfoHeader(info, link)
		if err != nil {
			return err
		}

		// 文件名，去除最外层的
		header.Name = strings.TrimPrefix(path, filepath.Dir(rootDir))

		// 创建压缩包头信息
		err = tarWriter.WriteHeader(header)
		if err != nil {
			return err
		}

		// nothing more to do for non-regular
		if !info.Mode().IsRegular() {
			return nil
		}

		// 打开待压缩的文件
		reader, err := os.Open(path)
		if err != nil {
			return err
		}
		defer reader.Close()

		// 写入文件
		_, err = io.Copy(tarWriter, reader)

		return err
	})

	return
}

7.2.2 解压

func tgzExtract() {
	tgzFilename := `C:\Users\MSN\Downloads\log.tar.gz`
	baseDir := filepath.Dir(tgzFilename)

	// 解压文件
	reader, err := os.Open(tgzFilename)
	if err != nil {
		log.Fatal(err)
	}
	defer reader.Close()

	err = ExtractTarGz(reader, baseDir)
	if err != nil {
		log.Fatal(err)
	}
	reader.Close()
}

func ExtractTarGz(reader io.Reader, baseDir string) error {
	gzipReader, err := gzip.NewReader(reader)
	if err != nil {
		return err
	}

	tarReader := tar.NewReader(gzipReader)

	for {
		header, err := tarReader.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}

		filename := filepath.Join(baseDir, header.Name)

		switch header.Typeflag {
		case tar.TypeDir:
			if err = os.MkdirAll(filename, fs.FileMode(header.Mode)); err != nil {
				return err
			}
		case tar.TypeReg:
			outFile, err := os.OpenFile(filename, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, fs.FileMode(header.Mode))
			if err != nil {
				return err
			}
			_, err = io.Copy(outFile, tarReader)
			if err != nil {
				return err
			}
			outFile.Close()
		default:
			log.Printf("unknown type: %c in %s\n", header.Typeflag, header.Name)
		}
	}

	return nil
}

8. 临时文件

未指定目录时，在系统临时目录下创建，名称随机的

func main() {
	tmpDir, err := ioutil.TempDir("", "temp")
	if err != nil {
		panic(err)
	}
	defer os.RemoveAll(tmpDir)

	tmpFile, err := ioutil.TempFile(tmpDir, "tmp.txt")
	if err != nil {
		panic(err)
	}
	defer tmpFile.Close()

	var i byte
	for i = 0; i < 127; i++ {
		_, err = tmpFile.Write([]byte{i})
		if err != nil {
			panic(err)
		}
	}
}

9. 其他操作

// 清空文件 100 bytes
err := os.Truncate("abc.txt", 100)

// 重命名
err := os.Rename(oldPath, newPath)

// 删除文件
err := os.Remove("abc.txt")

// 文件权限
err := os.Chmod("abc.txt", 0700)

// 文件所有者
err := os.Chown("abc.txt", os.Getuid(), os.Getgid())

// 文件时间戳
lastAccessTime := time.Now().Add(30 * time.Second)
lastModifyTime := time.Now().Add(-2 * time.Hour)
err := os.Chtimes("abc.txt", lastAcessTime, lastModifyTime)

// 硬链接
err := os.Link("abc.txt", "abc.txt.1")

// 软链接
err := os.Symlink("abc.txt", "abc_sym.txt")
elihe2011
关注
专栏目录
深入了解 Golang 文件操作：从创建到复制，掌握文件读写的基本操作和高效处理大文件的技巧
canduecho的专栏
06-26 802
在 Golang 中，文件操作是日常开发中不可或缺的一部分。本文将介绍如何使用 Golang 进行文件操作的基本操作，包括创建文件、写入文件、读取文件和复制文件。此外，还将探讨如何在不打开文件的情况下进行文件的读写操作，以及如何高效处理大文件。
golang文件读写操作
abcnull 的博客
05-29 1012
文章目录 golang 常用输入输出 常用：读取文件成 []byte 一种是生成 File，再利用 File 读或者写；另一种通过 ioutil 包直接对某路径下文件进行读写 // 依据相对路径拿到 *File 类型 jsonFile, err := os.Open(path) defer jsonFile.Close() // 将读取的文件读成 []byte jsonData, err := ioutil.ReadAll(jsonFile) // 通过序列化机制，把 []byte 转成特定结构 struc
Golang文件操作
最新发布
2021dragon的博客
05-22 1985
文件操作是指对计算机文件进行读取、写入、修改、删除和移动等操作的过程，它可以用于读取配置文件、存储日志、处理用户上传的文件等，Go中主要通过os和bufio包提供文件操作功能。文件在程序中是以流的形式进行操作的，我们把数据在数据源（文件）和程序（内存）之间经历的路径叫做流。其中数据从数据源到程序的路径叫做输入流，数据从程序到数据源的路径叫做输出流。基本介绍命令行参数是在运行程序时通过命令行传递给程序的参数，在Go中可以使用os包的Args变量来访问命令行参数。
【Golang文件操作】
m0_60657566的博客
03-06 419
文件操作一、打开文件和关闭文件二、读文件操作应用实例三、写文件操作应用实例四、文件编程实例五、命令行参数六、JSON基本介绍七、JSON的序列化八、JSON的反序列化总结 一、打开文件和关闭文件 1）概念 2） package main import( "fmt" "os" ) func main(){ file,err:=os.Open("d:/test.txt") if err!=nil{ fmt.Println("open err",err) } fmt.Println("f..
golang 文件操作
qq_39657769的博客
03-22 1983
1.文件基础操作 package main import( "fmt" "os" ) func main(){ //打开文件 file , err := os.Open("d:/test.txt") if err != nil { fmt.Println("file错误信息：",err) } else { //输入内容 返回的是一个指针 fmt.Printf("file = %v",&file) //结果：file = 0xc000006028 } //关
golang文件操作
月守护的博客
11-13 218
创建目录（os包） 创建单个目录 func Mkdir func Mkdir(name string, perm FileMode) error Mkdir使用指定的权限和名称创建一个目录。如果出错，会返回*PathError底层类型的错误 err:=os.Mkdir("./dir1",0755) if err!=nil{ fmt.Println(err) } 创建多级目录 func M...
十六、Golang文件操作详解
阿澈不吃蒜的博客
08-20 300
从 Go 1.16 开始，现在提供了相同的功能 通过包或包，以及这些实现 应该在新代码中首选。有关详细信息，请参阅特定函数文档。弃用了"io/ioutil"对文件的操作。
【Golang】文件操作
豆豆花的博客
01-22 351
*本文笔记参考：b站【尚硅谷】Golang入门到实战教程 1、文件的基本介绍 文件是数据源(保存数据的地方)的一种，如word, excel, txt都是文件。文件最主要的作用就是保存数据。 流：数据在数据源(文件)和程序(内存)之间经历的路径。 输入流(读文件)：数据从数据源(文件)到程序(内存)的路径。 输出流(写文件)：数据从程序(内存)到数据源(文件)的路径。 2、打开、关闭文件 //打开文件 file, err := os.Open("E:/study/Go_WorkSpace/s
Golang:Golang文件操作
ZzzWClock的博客
01-14 669
Golang文件操作 一.文件操作 1.关于文件操作 需要使用到os包 os.open 打开文件流 返回一个file指针 file.close 关闭文件流 读取文件是对文件的一个输入流 写入文件是对文件的一个输出流 二.实例 1.打开一个文件流 要记得用defer关闭一个文件流,否则会内存泄漏 2.读取文件流内容 读取文件内容,需要用到bufio包 bufio.NewReader()(带缓冲区的方式打开,适合打开较大的文件) reader.ReadString()(读取文件) io
Go基础编程：文件操作
秋叶原 && Mike || 麦克
01-17 5206
1 相关api介绍 1.1 建立与打开文件 新建文件可以通过如下两个方法： func Create(name string) (file *File, err Error) 根据提供的文件名创建新的文件，返回一个文件对象，默认权限是0666的文件，返回的文件对象是可读写的。 func NewFile(fd uintptr, name string) *File 根据文件描述符创建相...
Golang文件操作大全
什么都不会
02-06 464
【代码】Golang文件操作大全。
golang操作文件
磊哥聊Java
04-28 393
1、读取文件信息： /* 读取文件信息 */ func readFile(path string) string { fi, err := os.Open(path) if err != nil { panic(err) } defer fi.Close() fd, err := ioutil.ReadAll(fi) return string(fd)
golang常用库之-文件操作（os、path、filepath、ioutil包）、Go 读文件、Go 写文件
西京刀客
03-27 7278
Go官方提供的文件操作标准库分散在os、ioutil等多个包中，里面有非常多的方法涵盖了文件操作的所有场景.
golang文件操作-1
qq_63429769的博客
04-04 569
文章目录文件操作-1文件的基本介绍：文件的概念：输入流和输出流os.File封装所有对文件相关操作，File是一个结构体打开文件和关闭文件使用的函数和方法案例演示读文件操作应用实例：写文件操作和应用实例基本介绍os.OpenFile函数基本应用实例-方式一基本应用实例-方式二判断文件是否存在文件编程应用实例拷贝文件统计英文、数字、空格和其他字符的数量 文件操作-1 文件的基本介绍： 文件的概念： ​ 文件，对我们不陌生，文件时数据源（保存数据的地方）的一种，不如大家经常使用的word文档，txt文档，ex
golang学习笔记--文件操作
xxzed的博客
05-06 515
在go中要操作文件需要使用包//打开文件的常量，可以使用 | 拼接使用多个const (O_RDONLY// 只读模式打开文件O_WRONLY// 只写模式打开文件O_RDWR// 读写模式打开文件O_APPEND// 写操作时将数据附加到文件尾部O_CREATE// 如果不存在将创建一个新文件O_EXCL// 和O_CREATE配合使用，文件必须不存在O_SYNC// 打开文件用于同步I/OO_TRUNC// 如果可能，打开时清空文件。
Golang学习（八）：文件操作
平什么阿的博客
05-04 784
文章目录1. 文件的操作2. 打开和关闭文件3. 读取文件并显示到终端3.1 bufio.NewReader(file) 带缓存读取3.2 ioutil.ReadFile(file) 一次性读取4. 写文件操作应用实例4.1 os.OpenFile函数4.2 基本应用实例-方式一4.3 基本应用实例-方式二5. 文件编程应用实例5.1 拷贝文件5.2 统计英文、数字、空格和其他字符数量6. 命令行参数6.1 os.Args6.2 flag包用来解析命令行参数7. json7.1 概述7.2 json 序列化
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值