Go 语言文件操作实战：读写、压缩与目录管理

1.4 文件寻址

使用 Seek 方法移动文件指针，支持相对当前位置或绝对位置跳转。

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

	// 从开头偏移 5 个字节
	pos, _ := file.Seek(5, io.SeekStart)
	fmt.Println("Position:", pos)

	// 从当前位置回退 2 个字节
	pos, _ = file.Seek(-2, io.SeekCurrent)
	fmt.Println("Position:", pos)
}

1.5 分隔符读取

利用 Scanner 按单词或自定义规则分割内容。

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

	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanWords)

	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
	if err := scanner.Err(); err != nil {
		panic(err)
	}
}

1.6 按行读取

比 ReadString 更高效，自动处理换行符。

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

	reader := bufio.NewReader(file)
	for {
		line, _, err := reader.ReadLine()
		if err == io.EOF {
			break
		}
		if err != nil {
			panic(err)
		}
		fmt.Printf("%s\n", line)
	}
}

2. 文件写入

写入模式决定了数据如何被保存，常见有覆盖、追加等。

2.1 常规写入

使用 OpenFile 指定标志位，灵活控制行为。

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()

	_, err = file.Write([]byte("hello world!"))
	if err != nil {
		panic(err)
	}
	fmt.Println("Wrote bytes")
}

2.2 快速写入

覆盖写，适合配置重置或小数据写入。

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

2.3 缓冲写入

批量写入时减少 IO 开销，记得最后调用 Flush。

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

	writer := bufio.NewWriter(file)
	writer.WriteString("Buffered string\n")
	writer.Flush()
}

3. 文件拷贝

小文件可直接读取后写入，大文件建议使用 io.Copy。

3.1 直接拷贝

func main() {
	bs, err := os.ReadFile("src.txt")
	if err != nil {
		panic(err)
	}
	err = os.WriteFile("dst.txt", bs, 0600)
	if err != nil {
		panic(err)
	}
}

3.2 缓冲拷贝

适合大文件，内部使用默认缓冲区。

func CopyFile(dstFileName, srcFileName string) (written int64, err error) {
	srcFile, err := os.Open(srcFileName)
	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()

	return io.Copy(dstFile, srcFile)
}

4. 文件信息与统计

获取元数据或进行字符统计。

4.1 文件信息

func statFile() {
	info, err := os.Stat("abc.txt")
	if err != nil {
		if os.IsNotExist(err) {
			fmt.Println("file not exist")
			return
		}
		panic(err)
	}
	fmt.Println("Name:", info.Name())
	fmt.Println("Size:", info.Size())
	fmt.Println("Mode:", info.Mode())
	fmt.Println("IsDir:", info.IsDir())
}

4.2 字符统计

遍历文件内容并分类计数。

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', 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. 目录遍历

递归查找文件，常用于备份或清理。

func main() {
	err := filepath.Walk("/tmp", func(path string, info fs.FileInfo, err error) error {
		if err != nil {
			return err
		}
		fmt.Println(path)
		return nil
	})
	if err != nil {
		panic(err)
	}
}

6. 压缩文件

支持 zip 和 tar.gz 格式。

6.1 Zip 压缩与解压

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

	return filepath.Walk(rootDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		header, _ := zip.FileInfoHeader(info)
		header.Name = strings.TrimPrefix(path, filepath.Dir(rootDir))
		if info.IsDir() {
			header.Name += "/"
		} else {
			header.Method = zip.Deflate
		}
		fileWriter, _ := zipWriter.CreateHeader(header)
		if !info.Mode().IsRegular() {
			return nil
		}
		reader, _ := os.Open(path)
		defer reader.Close()
		_, err = io.Copy(fileWriter, reader)
		return 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.File {
		zippedFile, err := file.Open()
		if err != nil {
			return err
		}
		defer zippedFile.Close()

		extractedFilePath := filepath.Join(baseDir, file.Name)
		if file.FileInfo().IsDir() {
			os.MkdirAll(extractedFilePath, file.Mode())
		} else {
			outFile, err := os.OpenFile(extractedFilePath, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, file.Mode())
			if err != nil {
				return err
			}
			io.Copy(outFile, zippedFile)
			outFile.Close()
		}
	}
	return nil
}

6.2 Tar & Gzip

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

	return 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 {
			link, _ = os.Readlink(path)
		}
		header, _ := tar.FileInfoHeader(info, link)
		header.Name = strings.TrimPrefix(path, filepath.Dir(rootDir))
		tarWriter.WriteHeader(header)
		if !info.Mode().IsRegular() {
			return nil
		}
		reader, _ := os.Open(path)
		defer reader.Close()
		io.Copy(tarWriter, reader)
		return nil
	})
}

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

	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:
			os.MkdirAll(filename, fs.FileMode(header.Mode))
		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
			}
			io.Copy(outFile, tarReader)
			outFile.Close()
		}
	}
	return nil
}

7. 临时文件

系统会自动清理，无需手动删除。

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

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

	tmpFile.Write([]byte("test"))
}

8. 其他常用操作

包括截断、重命名、权限修改等。

func main() {
	// 清空或截断文件
	err := os.Truncate("abc.txt", 100)
	// 重命名
	err = os.Rename("old.txt", "new.txt")
	// 删除文件
	err = os.Remove("abc.txt")
	// 修改权限
	err = os.Chmod("abc.txt", 0700)
	// 修改时间戳
	err = os.Chtimes("abc.txt", time.Now(), time.Now())
	// 创建软链接
	err = os.Symlink("abc.txt", "abc_sym.txt")
}

以上涵盖了 Go 文件操作的核心 API。实际开发中请根据业务需求选择合适的方案，并注意错误处理和资源释放。