실행 가능한 Go 문서: 파일 읽기와 쓰기

Q: Go에서 파일 전체를 문자열로 읽으려면 어떻게 하나요?

data, err := os.ReadFile("notes.txt")는 내용을 []byte로 반환하며, string(data)로 변환합니다. 파일을 열고, 읽고, 닫는 일을 대신 해 줍니다. 메모리에 넉넉히 들어가는 파일에 쓰고, 큰 파일은 bufio.Scanner로 한 줄씩 읽으세요.

Q: Go에서 파일을 한 줄씩 읽으려면 어떻게 하나요?

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로 대부분의 필요를 해결할 수 있습니다. 한 번의 호출로 열고, 쓰거나 읽고, 닫습니다.

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은 필요하면 파일을 만들고, 이미 있으면 내용을 비웁니다. 세 번째 인자는 새로 만드는 파일의 Unix 권한입니다. 0o644는 소유자가 읽고 쓸 수 있고 나머지는 읽을 수 있다는 뜻입니다. 이미 있는 파일에는 무시되고, 프로세스의 umask가 일부 비트를 지울 수 있습니다.

os.ReadFile은 전부를 메모리로 읽습니다. 설정 파일과 작은 입력에는 알맞지만, 몇 기가바이트짜리 로그에는 맞지 않습니다.

bufio.Scanner로 한 줄씩 읽기

큰 파일이거나 어차피 줄 단위가 필요하다면 bufio.Scanner를 쓰세요. 덩어리로 읽어서 줄바꿈을 뺀 한 줄씩 건네줍니다.

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

세 가지 세부 사항:

반복이 끝나면 sc.Err()를 확인하세요. Scan은 파일 끝에서도, 오류가 났을 때도 false를 반환하며, 둘을 구분하는 것은 Err뿐입니다.
64KB 줄 길이 제한. 기본적으로 64KB보다 긴 줄 하나가 있으면 스캐너가 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`	읽기, 쓰기, 또는 둘 다를 위해 열기(하나 선택)
`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을 쓰세요. 확인과 생성이 원자적인 한 단계가 됩니다.

디렉터리

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

작업	함수
디렉터리 하나 만들기	`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를 쓰세요. 운영체제에 맞는 구분자(Windows에서는 \)를 씁니다. path 패키지는 URL처럼 슬래시로 구분된 경로용입니다.

Go 1.24에는 os.Root(os.OpenRoot(dir))도 추가되었습니다. 한 디렉터리 안의 파일만 열고, ..나 심볼릭 링크로 빠져나가는 경로는 거부합니다. 파일 이름이 사용자에게서 올 때 쓰세요.

흔한 실수

오류를 확인하지 않음. 이 호출들은 모두 실패할 수 있습니다. 열기에 실패한 파일은 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로 한 줄씩 읽으세요.

Go에서 파일을 한 줄씩 읽으려면 어떻게 하나요?

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)는 알 수 없다는 뜻이므로 "없음"으로 취급하지 말고 따로 처리하세요.