実行できるGoドキュメント: ファイルの読み書き

Q: Goでファイル全体を文字列として読むには？

data, err := os.ReadFile("notes.txt") は内容を []byte で返すので、string(data) で変換します。ファイルを開いて読んで閉じるところまでやってくれます。メモリに余裕で収まるファイルに使い、大きなファイルは bufio.Scanner で1行ずつ読みます。

Q: Goでファイルを1行ずつ読むには？

os.Open でファイルを開き、defer f.Close() とし、bufio.NewScanner(f) で包んで、for sc.Scan() { line := sc.Text() } でループし、ループの後で sc.Err() をチェックします。64KBより長い行があると、sc.Buffer でバッファを大きくしない限り、スキャナーは token too long で失敗します。

Q: Goでファイルに追記するには？

os.OpenFile(name, os.OAPPEND|os.OCREATE|os.OWRONLY, 0o644) で開き、書き込んで、Close のエラーをチェックします。OCREATE はファイルがなければ作り、O_APPEND はすべての書き込みを末尾に行わせます。

Q: Goでファイルが存在するか確認するには？

os.Stat(path) を呼び、そのエラーを errors.Is(err, fs.ErrNotExist) でテストします。エラーがnilなら存在します。それ以外のエラー（たとえばpermission denied）は判断がつかないことを意味するので、「存在しない」として扱わず、別に処理します。

ファイル全体を読み書きする

ほとんどの用途は os.WriteFile と os.ReadFile でまかなえます。開く、書くか読む、閉じるを1回の呼び出しで行います。

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

このページの例は、os.MkdirTemp で作った一時ディレクトリで作業し、defer os.RemoveAll(dir) で削除するので、何も残しません。自分のコードでは、"config.json" のような相対パスはプロセスの作業ディレクトリを基準に解決されます。それはソースファイルやバイナリのディレクトリとは限りません。

os.WriteFile は必要ならファイルを作り、存在すれば 切り詰めます。3つ目の引数は、新しく作るファイルのUnixのパーミッションです。0o644 は所有者が読み書きでき、他の人は読めるという意味です。すでにあるファイルでは無視され、プロセスのumaskによってビットが削られることもあります。

os.ReadFile はすべてをメモリに読み込みます。設定ファイルや小さな入力にはそれが正しく、数ギガバイトのログには間違いです。

bufio.Scannerで1行ずつ読む

大きなファイルや、どのみち行単位で扱いたいときは bufio.Scanner を使います。まとまった単位で読み、改行を除いた行を1つずつ渡してくれます。

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

細かな点が3つあります。

ループの後で sc.Err() をチェックする。 Scan はファイルの終わりでもエラーでも false を返し、区別できるのは Err だけです。
64KBの行の上限。 デフォルトでは、64KBより長い1行があるとスキャナーは bufio.Scanner: token too long で止まります。長い行を含むファイル（圧縮されたJSON、一部のログ）では、ループの前に上限を引き上げます：sc.Buffer(make([]byte, 1024*1024), 10*1024*1024)。
他の単位。 sc.Split(bufio.ScanWords) は単語を、bufio.ScanRunes は文字を返します。

行ではなく固定サイズのかたまりでストリームを読むには、ループで f.Read(buf) を使うか、io.Copy で別のWriterに渡します。

書き込み：os.Create、os.OpenFile、追記

os.Create(name) は書き込み用にファイルを開き、作成するか切り詰めます。os.OpenFile はフラグですべてを制御できます。

フラグ	意味
`os.O_RDONLY`、`os.O_WRONLY`、`os.O_RDWR`	読み取り、書き込み、または両方のために開く（1つを選ぶ）
`os.O_CREATE`	ファイルがなければ作る
`os.O_TRUNC`	開くときにファイルを空にする
`os.O_APPEND`	すべての書き込みが末尾に行われる
`os.O_EXCL`	`O_CREATE` と組み合わせて、ファイルがすでにあれば失敗する

os.Open(name) は OpenFile(name, O_RDONLY, 0) と同じです。os.Create(name) は 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")
}

書き込むときは Close のエラーが重要です。ファイルシステムによっては、書き込みの失敗をクローズの時点でしか報告しないので、defer f.Close() だけではデータの喪失を隠してしまうことがあります。書き込むファイルでは、appendLine のように Close を明示的にチェックします。読むだけのファイルなら defer f.Close() で問題ありません。

fmt.Fprintln をはじめとするfmtの表示関数は、ファイルを含む任意の io.Writer を受け付けます。bufio.Writer は小さな書き込みをメモリにためてまとめます。w.Flush() を忘れるのは典型的なバグで、プログラムは正常に終了し、最後の数キロバイトがファイルに届きません。

ファイルは存在するか

Goに os.Exists はありません。os.Stat を呼んでエラーを調べます。

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) が現在のイディオムです。ラップされたエラーを見通せない古い os.IsNotExist(err) に代わるものです。

開く前にチェックするのは、たいてい不要で、競合も起こします。チェックと開く操作の間にファイルが現れたり消えたりしうるからです。普通は単に開いて、開く操作から返る fs.ErrNotExist を処理します。まだ存在しないときだけファイルを作るには、O_CREATE|O_EXCL を使うと、チェックと作成が1つの不可分な手順になります。

ディレクトリ

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

やりたいこと	関数
ディレクトリを1つ作る	`os.Mkdir(path, 0o755)`
親を含めてパスを作る	`os.MkdirAll(path, 0o755)`
ディレクトリの一覧	`os.ReadDir(path)`
ツリーをたどる	`filepath.WalkDir(root, fn)`
ファイルか空のディレクトリを削除する	`os.Remove(path)`
ツリーを削除する	`os.RemoveAll(path)`
名前の変更や移動	`os.Rename(old, new)`
一時ファイルや一時ディレクトリ	`os.CreateTemp("", "prefix-*")`、`os.MkdirTemp("", "prefix")`
パスの部品をつなぐ	`filepath.Join(a, b, c)`

ファイルシステムのパスには path/filepath を使います。OSに合った区切り文字（Windowsでは \）を使ってくれます。path パッケージは、URLのようなスラッシュ区切りのパスのためのものです。

Go 1.24では os.Root（os.OpenRoot(dir)）も追加されました。1つのディレクトリの中でだけファイルを開き、.. やシンボリックリンクで外に出るパスを拒否します。ファイル名がユーザーから来る場合に使います。

よくある間違い

エラーをチェックしない。 これらの呼び出しはどれも失敗しえます。開けなかったファイルは nil で、その後の Read、Write、Close はすべて invalid argument を返し、本当の原因（ファイルがなかった、権限がなかった）を隠します。
スキャンのループの後で sc.Err() を忘れる。 読み取りのエラーがファイルの終わりに見えます。
bufio.Writer の Flush を忘れる。 ファイルの終わりが欠けます。
書き込み後の Close のエラーを無視する。 書き込みのエラーはそこでしか表に出ないことがあります。
多くのファイルをループする中での defer f.Close()。 関数が戻るまでファイルが開いたままになり、ファイルディスクリプタを使い果たすことがあります。本体を関数に移して、反復ごとにファイルが閉じるようにします。
パーミッションを10進数で書く。 644 は 0o644 ではありません。Goは 644 を10進数として読むので 0o1204 になり、おかしなビットが立ちます。

よくある質問

Goでファイル全体を文字列として読むには？

data, err := os.ReadFile("notes.txt") は内容を []byte で返すので、string(data) で変換します。ファイルを開いて読んで閉じるところまでやってくれます。メモリに余裕で収まるファイルに使い、大きなファイルは bufio.Scanner で1行ずつ読みます。

Goでファイルを1行ずつ読むには？

os.Open でファイルを開き、defer f.Close() とし、bufio.NewScanner(f) で包んで、for sc.Scan() { line := sc.Text() } でループし、ループの後で sc.Err() をチェックします。64KBより長い行があると、sc.Buffer でバッファを大きくしない限り、スキャナーは token too long で失敗します。

Goでファイルに追記するには？

os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644) で開き、書き込んで、Close のエラーをチェックします。O_CREATE はファイルがなければ作り、O_APPEND はすべての書き込みを末尾に行わせます。

Goでファイルが存在するか確認するには？

os.Stat(path) を呼び、そのエラーを errors.Is(err, fs.ErrNotExist) でテストします。エラーがnilなら存在します。それ以外のエラー（たとえばpermission denied）は判断がつかないことを意味するので、「存在しない」として扱わず、別に処理します。