Membaca dan Menulis File di Golang: os, bufio, dan Direktori

Membaca dan menulis seluruh isi file

os.WriteFile dan os.ReadFile sudah mencakup kebanyakan kebutuhan. Keduanya membuka, menulis atau membaca, lalu menutup file dalam satu pemanggilan.

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

Contoh-contoh di halaman ini bekerja di direktori sementara dari os.MkdirTemp dan menghapusnya dengan defer os.RemoveAll(dir), jadi tidak ada yang tertinggal. Di kodemu sendiri, path relatif seperti "config.json" dicari berdasarkan direktori kerja proses, yang belum tentu sama dengan direktori file sumber atau binary-nya.

os.WriteFile membuat file kalau perlu dan mengosongkannya (truncate) kalau file itu sudah ada. Argumen ketiga adalah izin Unix untuk file yang baru dibuat: 0o644 berarti pemiliknya bisa membaca dan menulis, orang lain hanya bisa membaca. Argumen ini diabaikan untuk file yang sudah ada, dan umask proses bisa menghapus sebagian bit-nya.

os.ReadFile membaca semuanya ke memori. Itu tepat untuk file konfigurasi dan input kecil, dan salah untuk log berukuran beberapa gigabyte.

Membaca baris demi baris dengan bufio.Scanner

Untuk file besar, atau saat kamu memang ingin bekerja per baris, pakai bufio.Scanner. Scanner membaca per potongan dan memberimu satu baris setiap kali, tanpa karakter baris baru.

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")
}

Tiga detail:

• Periksa sc.Err() setelah perulangan. Scan mengembalikan false baik di akhir file maupun saat terjadi error, dan hanya Err yang bisa membedakannya.
• Batas baris 64 KB. Secara default, satu baris yang lebih panjang dari 64 KB menghentikan scanner dengan bufio.Scanner: token too long. Untuk file dengan baris panjang (JSON yang di-minify, sebagian log), naikkan batasnya sebelum perulangan: sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
• Satuan lain. sc.Split(bufio.ScanWords) menghasilkan kata; bufio.ScanRunes menghasilkan karakter.

Untuk membaca stream dalam potongan berukuran tetap alih-alih per baris, pakai f.Read(buf) di dalam perulangan atau io.Copy ke writer lain.

Menulis: os.Create, os.OpenFile, dan append

os.Create(name) membuka file untuk ditulis, dengan membuat atau mengosongkannya. os.OpenFile memberi kendali penuh lewat flag:

os.Open(name) sama dengan OpenFile(name, O_RDONLY, 0). os.Create(name) sama dengan 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")
}

Saat menulis, error dari Close itu penting. Sebagian file system baru melaporkan kegagalan penulisan saat file ditutup, jadi defer f.Close() saja bisa menyembunyikan data yang hilang. Untuk file yang kamu tulis, periksa Close secara eksplisit seperti yang dilakukan appendLine. Untuk file yang hanya kamu baca, defer f.Close() tidak masalah.

fmt.Fprintln dan fungsi cetak fmt lainnya menerima io.Writer apa pun, termasuk file. bufio.Writer mengumpulkan penulisan kecil di memori. Lupa memanggil w.Flush() adalah bug klasik: program selesai dengan normal dan beberapa kilobyte terakhir tidak pernah sampai ke file.

Apakah file itu ada?

Go tidak punya os.Exists. Panggil os.Stat dan periksa error-nya:

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) adalah idiom yang berlaku sekarang. Idiom ini menggantikan os.IsNotExist(err) yang lebih lama, yang tidak bisa melihat ke dalam error yang dibungkus.

Memeriksa sebelum membuka sering kali tidak perlu dan rawan race: file bisa muncul atau hilang di antara pemeriksaan dan pembukaan. Biasanya kamu cukup membukanya dan menangani fs.ErrNotExist dari pembukaan itu. Untuk membuat file hanya kalau file itu belum ada, pakai O_CREATE|O_EXCL, yang menjadikan pemeriksaan dan pembuatan satu langkah atomik.

Direktori

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

Pakai path/filepath untuk path file system: package ini memakai pemisah yang tepat untuk sistem operasinya (\ di Windows). Package path dipakai untuk path yang dipisahkan garis miring, seperti URL.

Go 1.24 juga menambahkan os.Root (os.OpenRoot(dir)), yang hanya membuka file di dalam satu direktori dan menolak path yang keluar darinya lewat .. atau symlink. Pakai saat nama file berasal dari pengguna.

Kesalahan umum

• Tidak memeriksa error. Setiap pemanggilan ini bisa gagal. File yang gagal dibuka bernilai nil, dan setiap Read, Write, atau Close setelahnya mengembalikan invalid argument, yang menyembunyikan penyebab sebenarnya (file-nya tidak ada, atau izinnya ditolak).
• Lupa sc.Err() setelah perulangan scan. Error saat membaca terlihat seperti akhir file.
• Lupa Flush pada bufio.Writer. Bagian akhir file hilang.
• Mengabaikan error dari Close setelah menulis. Error penulisan bisa saja baru muncul di sana.
• defer f.Close() di dalam perulangan atas banyak file. File-file itu tetap terbuka sampai fungsinya selesai dan kamu bisa kehabisan file descriptor. Pindahkan badan perulangan ke sebuah fungsi supaya setiap file ditutup per iterasi.
• Izin akses yang ditulis sebagai desimal. 644 tidak sama dengan 0o644. Go membaca 644 sebagai angka desimal, yaitu 0o1204, dan mengisi bit-bit yang aneh.