Đọc và ghi tệp trong Golang: os, bufio và thư mục

Đọc và ghi toàn bộ tệp

os.WriteFile và os.ReadFile đáp ứng hầu hết nhu cầu. Chúng mở, ghi hoặc đọc, rồi đóng tệp chỉ trong một lời gọi.

package main

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

func main() {
	dir, err := os.MkdirTemp("", "demo")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir) // clean up everything at the end

	path := filepath.Join(dir, "greeting.txt")

	if err := os.WriteFile(path, []byte("hello, file\nsecond line\n"), 0o644); err != nil {
		fmt.Println("write:", err)
		return
	}

	data, err := os.ReadFile(path)
	if err != nil {
		fmt.Println("read:", err)
		return
	}
	fmt.Print(string(data))
	fmt.Println("bytes:", len(data))
}

Các ví dụ trên trang này làm việc trong một thư mục tạm tạo bằng os.MkdirTemp và xóa nó bằng defer os.RemoveAll(dir), nên không để lại gì. Trong code của bạn, một đường dẫn tương đối như "config.json" được tính từ thư mục làm việc của tiến trình, không nhất thiết là thư mục chứa tệp mã nguồn hay tệp thực thi.

os.WriteFile tạo tệp nếu cần và xóa sạch nội dung (truncate) nếu tệp đã tồn tại. Đối số thứ ba là quyền Unix cho tệp mới được tạo: 0o644 nghĩa là chủ sở hữu được đọc và ghi, những người khác chỉ được đọc. Đối số này bị bỏ qua với tệp đã có sẵn, và umask của tiến trình có thể gỡ bớt một số bit.

os.ReadFile đọc toàn bộ vào bộ nhớ. Điều đó phù hợp với tệp cấu hình và đầu vào nhỏ, nhưng không phù hợp với một tệp log nhiều gigabyte.

Đọc từng dòng với bufio.Scanner

Với tệp lớn, hoặc khi bạn vốn cần xử lý theo dòng, hãy dùng bufio.Scanner. Nó đọc theo từng khối và trả cho bạn mỗi lần một dòng, không kèm ký tự xuống dòng.

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	f, err := os.CreateTemp("", "log-*.txt")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.Remove(f.Name())
	fmt.Fprintln(f, "INFO started")
	fmt.Fprintln(f, "ERROR disk full")
	fmt.Fprintln(f, "INFO retrying")
	fmt.Fprintln(f, "ERROR disk still full")
	f.Close()

	in, err := os.Open(f.Name())
	if err != nil {
		fmt.Println(err)
		return
	}
	defer in.Close()

	sc := bufio.NewScanner(in)
	lineNo, errorsSeen := 0, 0
	for sc.Scan() {
		lineNo++
		line := sc.Text()
		if strings.HasPrefix(line, "ERROR") {
			errorsSeen++
			fmt.Printf("line %d: %s\n", lineNo, line)
		}
	}
	if err := sc.Err(); err != nil { // Scan returns false on errors too
		fmt.Println("scan:", err)
		return
	}
	fmt.Println("errors:", errorsSeen, "of", lineNo, "lines")
}

Ba chi tiết cần lưu ý:

• Kiểm tra sc.Err() sau vòng lặp. Scan trả về false cả khi hết tệp lẫn khi gặp lỗi, và chỉ Err mới phân biệt được hai trường hợp này.
• Giới hạn dòng 64 KB. Theo mặc định, một dòng dài hơn 64 KB sẽ làm scanner dừng với bufio.Scanner: token too long. Với tệp có dòng dài (JSON đã minify, một số tệp log), hãy nâng giới hạn trước vòng lặp: sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
• Đơn vị khác. sc.Split(bufio.ScanWords) trả về từng từ; bufio.ScanRunes trả về từng ký tự.

Để đọc một luồng dữ liệu theo các khối kích thước cố định thay vì theo dòng, hãy dùng f.Read(buf) trong một vòng lặp hoặc io.Copy sang một writer khác.

Ghi tệp: os.Create, os.OpenFile và ghi nối thêm

os.Create(name) mở một tệp để ghi, tạo mới hoặc xóa sạch nội dung cũ. os.OpenFile cho bạn toàn quyền kiểm soát qua các flag:

os.Open(name) tương đương OpenFile(name, O_RDONLY, 0). os.Create(name) tương đương OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0o666).

package main

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

func appendLine(path, line string) error {
	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
	if err != nil {
		return err
	}
	if _, err := fmt.Fprintln(f, line); err != nil {
		f.Close()
		return err
	}
	return f.Close() // Close can report a failed write: return its error
}

func main() {
	dir, err := os.MkdirTemp("", "append")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir)
	path := filepath.Join(dir, "audit.log")

	for _, msg := range []string{"login alice", "upload report.pdf", "logout alice"} {
		if err := appendLine(path, msg); err != nil {
			fmt.Println("append:", err)
			return
		}
	}

	// Buffered writing: many small writes, one syscall per buffer.
	out, err := os.Create(filepath.Join(dir, "numbers.txt"))
	if err != nil {
		fmt.Println(err)
		return
	}
	w := bufio.NewWriter(out)
	for i := 1; i <= 1000; i++ {
		fmt.Fprintln(w, i)
	}
	if err := w.Flush(); err != nil { // without Flush the tail of the data is lost
		fmt.Println("flush:", err)
	}
	if err := out.Close(); err != nil {
		fmt.Println("close:", err)
	}

	data, _ := os.ReadFile(path)
	fmt.Print(string(data))
	info, _ := os.Stat(filepath.Join(dir, "numbers.txt"))
	fmt.Println("numbers.txt size:", info.Size(), "bytes")
}

Khi ghi tệp, lỗi từ Close rất quan trọng. Một số hệ thống tệp chỉ báo lỗi ghi vào lúc đóng tệp, nên chỉ dùng defer f.Close() có thể che giấu việc mất dữ liệu. Với tệp bạn ghi, hãy kiểm tra Close một cách tường minh như appendLine làm. Với tệp bạn chỉ đọc, defer f.Close() là đủ.

fmt.Fprintln và các hàm in của fmt khác nhận bất kỳ io.Writer nào, kể cả một tệp. bufio.Writer gom các lần ghi nhỏ lại trong bộ nhớ. Quên gọi w.Flush() là một bug kinh điển: chương trình thoát bình thường nhưng vài kilobyte cuối cùng không bao giờ được ghi vào tệp.

Tệp có tồn tại không?

Go không có os.Exists. Hãy gọi os.Stat và xem lỗi trả về:

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
)

func exists(path string) (bool, error) {
	_, err := os.Stat(path)
	if err == nil {
		return true, nil
	}
	if errors.Is(err, fs.ErrNotExist) {
		return false, nil
	}
	return false, err // permission denied, broken mount, ...: unknown
}

func main() {
	dir, err := os.MkdirTemp("", "exists")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir)

	fmt.Println(exists(dir))
	fmt.Println(exists(filepath.Join(dir, "nope.txt")))

	_, err = os.ReadFile(filepath.Join(dir, "nope.txt"))
	fmt.Println("not exist:", errors.Is(err, fs.ErrNotExist))
	fmt.Println(err)
}

errors.Is(err, fs.ErrNotExist) là cách viết chuẩn hiện nay. Nó thay cho os.IsNotExist(err) cũ, vốn không nhìn xuyên qua được các lỗi đã được wrap.

Kiểm tra trước khi mở thường không cần thiết và dễ gây race: tệp có thể xuất hiện hoặc biến mất giữa lúc kiểm tra và lúc mở. Thông thường bạn chỉ cần mở tệp và xử lý fs.ErrNotExist từ lệnh mở. Để chỉ tạo tệp khi nó chưa tồn tại, hãy dùng O_CREATE|O_EXCL, giúp việc kiểm tra và tạo tệp diễn ra trong một bước nguyên tử.

Thư mục

package main

import (
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
)

func main() {
	root, err := os.MkdirTemp("", "tree")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(root)

	// MkdirAll creates every missing parent, like mkdir -p.
	if err := os.MkdirAll(filepath.Join(root, "src", "util"), 0o755); err != nil {
		fmt.Println(err)
		return
	}
	for _, name := range []string{"main.go", "src/app.go", "src/util/strings.go", "README.md"} {
		if err := os.WriteFile(filepath.Join(root, name), []byte("x"), 0o644); err != nil {
			fmt.Println(err)
			return
		}
	}

	// One level: ReadDir returns entries sorted by name.
	entries, err := os.ReadDir(root)
	if err != nil {
		fmt.Println(err)
		return
	}
	for _, e := range entries {
		fmt.Printf("%-10s dir=%v\n", e.Name(), e.IsDir())
	}

	// Recursive: WalkDir visits every file and directory in lexical order.
	fmt.Println("Go files:")
	err = filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !d.IsDir() && filepath.Ext(path) == ".go" {
			rel, _ := filepath.Rel(root, path)
			fmt.Println(" ", filepath.ToSlash(rel))
		}
		return nil
	})
	if err != nil {
		fmt.Println(err)
	}

	// Glob matches one directory level against a pattern.
	matches, _ := filepath.Glob(filepath.Join(root, "*.md"))
	fmt.Println("markdown files:", len(matches))
}

Dùng path/filepath cho đường dẫn trong hệ thống tệp: package này dùng đúng ký tự phân cách của hệ điều hành (\ trên Windows). Package path dành cho các đường dẫn phân cách bằng dấu gạch chéo như URL.

Go 1.24 còn bổ sung os.Root (os.OpenRoot(dir)), chỉ mở tệp bên trong một thư mục và từ chối những đường dẫn thoát ra ngoài bằng .. hoặc symlink. Hãy dùng nó khi tên tệp đến từ người dùng.

Những lỗi thường gặp

• Không kiểm tra lỗi. Mọi lời gọi ở trên đều có thể thất bại. Một tệp mở không thành công sẽ là nil, và mọi lệnh Read, Write hay Close sau đó trên nó đều trả về invalid argument, che mất nguyên nhân thật (tệp không tồn tại, hoặc bị từ chối quyền truy cập).
• Quên sc.Err() sau vòng lặp scan. Một lỗi đọc trông giống như hết tệp.
• Quên Flush trên bufio.Writer. Phần cuối của tệp bị mất.
• Bỏ qua lỗi từ Close sau khi ghi. Lỗi ghi có thể chỉ xuất hiện ở đó.
• defer f.Close() trong vòng lặp qua nhiều tệp. Các tệp vẫn mở cho đến khi hàm trả về và bạn có thể dùng hết file descriptor. Hãy chuyển phần thân vòng lặp vào một hàm để mỗi tệp được đóng sau từng lần lặp.
• Viết quyền dưới dạng thập phân. 644 không phải 0o644. Go hiểu 644 là số thập phân, tức 0o1204, và đặt những bit kỳ lạ.