Golang Dosya Okuma ve Yazma: os, bufio ve Dizinler

Q: Go'da bir dosyanın tamamı bir string'e nasıl okunur?

data, err := os.ReadFile("notes.txt") içeriği []byte olarak döndürür; string(data) ile dönüştürün. Dosyayı sizin yerinize açar, okur ve kapatır. Belleğe rahatça sığan dosyalar için kullanın; büyük dosyalar için bufio.Scanner ile satır satır okuyun.

Q: Go'da bir dosya satır satır nasıl okunur?

Dosyayı os.Open ile açın, defer f.Close() yazın, onu bufio.NewScanner(f) ile sarın, for sc.Scan() { line := sc.Text() } ile dönün ve döngüden sonra sc.Err()'ü kontrol edin. 64 KB'tan uzun satırlar, tamponu sc.Buffer ile büyütmedikçe scanner'ın token too long ile başarısız olmasına yol açar.

Q: Go'da bir dosyanın sonuna nasıl ekleme yapılır?

Onu os.OpenFile(name, os.OAPPEND|os.OCREATE|os.OWRONLY, 0o644) ile açın, yazın ve Close'tan gelen hatayı kontrol edin. OCREATE dosya yoksa oluşturur, O_APPEND her yazmanın sona gitmesini sağlar.

Q: Go'da bir dosyanın var olup olmadığı nasıl kontrol edilir?

os.Stat(path)'i çağırın ve hatayı errors.Is(err, fs.ErrNotExist) ile test edin. Nil bir hata dosyanın var olduğu anlamına gelir. Başka herhangi bir hata (örneğin permission denied) bunu bilemeyeceğiniz anlamına gelir, bu yüzden onu "yok" olarak ele almak yerine ayrıca işleyin.

Bütün bir dosyayı okumak ve yazmak

os.WriteFile ve os.ReadFile çoğu ihtiyacı karşılar. Tek bir çağrıda açar, yazar ya da okur ve kapatırlar.

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

Bu sayfadaki örnekler os.MkdirTemp'ten gelen geçici bir dizinde çalışır ve onu defer os.RemoveAll(dir) ile kaldırır, böylece geride hiçbir şey bırakmazlar. Kendi kodunuzda "config.json" gibi göreli bir yol, sürecin çalışma dizinine göre çözülür; bu da mutlaka kaynak dosyanın ya da binary'nin dizini değildir.

os.WriteFile gerekirse dosyayı oluşturur ve varsa onu sıfırlar (truncate). Üçüncü argüman yeni oluşturulan bir dosya için Unix iznidir: 0o644, sahibinin okuyup yazabileceği, diğer herkesin okuyabileceği anlamına gelir. Zaten var olan bir dosya için yok sayılır ve süreç umask'ı bazı bitleri kaldırabilir.

os.ReadFile her şeyi belleğe okur. Bu yapılandırma dosyaları ve küçük girdiler için doğrudur, çok gigabaytlık bir log için yanlıştır.

bufio.Scanner ile satır satır okumak

Büyük dosyalar için ya da zaten satırları istediğinizde bufio.Scanner kullanın. Parçalar halinde okur ve size her seferinde yeni satır karakteri olmadan bir satır verir.

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

Üç ayrıntı:

Döngüden sonra sc.Err()'ü kontrol edin. Scan hem dosya sonunda hem de bir hatada false döndürür ve yalnızca Err onları ayırt eder.
64 KB satır sınırı. Varsayılan olarak 64 KB'tan uzun tek bir satır scanner'ı bufio.Scanner: token too long ile durdurur. Uzun satırlı dosyalar (küçültülmüş JSON, bazı loglar) için döngüden önce sınırı yükseltin: sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
Diğer birimler. sc.Split(bufio.ScanWords) kelimeler verir; bufio.ScanRunes karakterler verir.

Bir akışı satırlar yerine sabit boyutlu parçalar halinde okumak için bir döngüde f.Read(buf) kullanın ya da başka bir writer'a io.Copy yapın.

Yazmak: os.Create, os.OpenFile ve sona ekleme

os.Create(name) bir dosyayı yazmak için açar; oluşturur ya da sıfırlar. os.OpenFile bayraklar üzerinden tam kontrol verir:

Bayrak	Anlamı
`os.O_RDONLY`, `os.O_WRONLY`, `os.O_RDWR`	okumak, yazmak ya da ikisi için aç (birini seçin)
`os.O_CREATE`	dosya yoksa oluştur
`os.O_TRUNC`	açarken dosyayı boşalt
`os.O_APPEND`	her yazma sona gider
`os.O_EXCL`	`O_CREATE` ile: dosya zaten varsa başarısız ol

os.Open(name), OpenFile(name, O_RDONLY, 0)'dır. os.Create(name), OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0o666)'dır.

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

Yazarken Close'tan gelen hata önemlidir. Bazı dosya sistemleri yazma hatalarını yalnızca kapatma anında bildirir, bu yüzden tek başına defer f.Close() kaybolan veriyi gizleyebilir. Yazdığınız dosyalar için appendLine'ın yaptığı gibi Close'u açıkça kontrol edin. Yalnızca okuduğunuz dosyalar için defer f.Close() yeterlidir.

fmt.Fprintln ve fmt yazdırma fonksiyonlarının geri kalanı, bir dosya dahil her io.Writer'ı kabul eder. Bir bufio.Writer küçük yazmaları bellekte toplar. w.Flush()'ı unutmak klasik bir hatadır: program normal biçimde çıkar ve son birkaç kilobayt dosyaya hiç ulaşmaz.

Dosya var mı?

Go'da os.Exists yoktur. os.Stat'ı çağırın ve hatayı inceleyin:

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) güncel kalıptır. Sarmalanmış hataların içini göremeyen eski os.IsNotExist(err)'ün yerini alır.

Açmadan önce kontrol etmek çoğu zaman gereksizdir ve race'e açıktır: dosya kontrol ile açma arasında ortaya çıkabilir ya da kaybolabilir. Genellikle onu doğrudan açıp açmadan gelen fs.ErrNotExist'i ele alırsınız. Bir dosyayı yalnızca henüz yoksa oluşturmak için, kontrolü ve oluşturmayı tek bir atomik adım yapan O_CREATE|O_EXCL'i kullanın.

Dizinler

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

Görev	Fonksiyon
tek bir dizin oluşturmak	`os.Mkdir(path, 0o755)`
ebeveynleriyle bir yol oluşturmak	`os.MkdirAll(path, 0o755)`
bir dizini listelemek	`os.ReadDir(path)`
bir ağacı dolaşmak	`filepath.WalkDir(root, fn)`
bir dosyayı ya da boş dizini silmek	`os.Remove(path)`
bir ağacı silmek	`os.RemoveAll(path)`
yeniden adlandırmak ya da taşımak	`os.Rename(old, new)`
geçici dosya ya da dizin	`os.CreateTemp("", "prefix-*")`, `os.MkdirTemp("", "prefix")`
yol parçalarını birleştirmek	`filepath.Join(a, b, c)`

Dosya sistemi yolları için path/filepath kullanın: işletim sistemi için doğru ayırıcıyı kullanır (Windows'ta \). path paketi ise URL'ler gibi eğik çizgiyle ayrılmış yollar içindir.

Go 1.24 ayrıca dosyaları yalnızca tek bir dizinin içinde açan ve .. ya da symlink'lerle dışarı kaçan yolları reddeden os.Root'u (os.OpenRoot(dir)) ekledi. Dosya adları kullanıcılardan geldiğinde onu kullanın.

Sık yapılan hatalar

Hataları kontrol etmemek. Bu çağrıların her biri başarısız olabilir. Açılamayan bir dosya nil'dir ve üzerindeki sonraki her Read, Write ya da Close invalid argument döndürür; bu da asıl nedeni (dosya yoktu ya da izin reddedildi) gizler.
Bir tarama döngüsünden sonra sc.Err()'ü unutmak. Bir okuma hatası dosya sonu gibi görünür.
Bir bufio.Writer üzerinde Flush'ı unutmak. Dosyanın sonu eksik kalır.
Yazdıktan sonra Close'tan gelen hatayı yok saymak. Yazma hataları yalnızca orada ortaya çıkabilir.
Birçok dosya üzerinde dönen bir döngü içinde defer f.Close(). Dosyalar fonksiyon dönene kadar açık kalır ve dosya tanımlayıcılarınız tükenebilir. Gövdeyi bir fonksiyona taşıyın ki her dosya yinelemede kapansın.
Onluk olarak yazılmış izinler. 644, 0o644 değildir. Go 644'ü onluk sayı olarak okur; bu da 0o1204'tür ve tuhaf bitler ayarlar.

Sıkça Sorulan Sorular

Go'da bir dosyanın tamamı bir string'e nasıl okunur?

data, err := os.ReadFile("notes.txt") içeriği []byte olarak döndürür; string(data) ile dönüştürün. Dosyayı sizin yerinize açar, okur ve kapatır. Belleğe rahatça sığan dosyalar için kullanın; büyük dosyalar için bufio.Scanner ile satır satır okuyun.

Go'da bir dosya satır satır nasıl okunur?

Dosyayı os.Open ile açın, defer f.Close() yazın, onu bufio.NewScanner(f) ile sarın, for sc.Scan() { line := sc.Text() } ile dönün ve döngüden sonra sc.Err()'ü kontrol edin. 64 KB'tan uzun satırlar, tamponu sc.Buffer ile büyütmedikçe scanner'ın token too long ile başarısız olmasına yol açar.

Go'da bir dosyanın sonuna nasıl ekleme yapılır?

Onu os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644) ile açın, yazın ve Close'tan gelen hatayı kontrol edin. O_CREATE dosya yoksa oluşturur, O_APPEND her yazmanın sona gitmesini sağlar.

Go'da bir dosyanın var olup olmadığı nasıl kontrol edilir?

os.Stat(path)'i çağırın ve hatayı errors.Is(err, fs.ErrNotExist) ile test edin. Nil bir hata dosyanın var olduğu anlamına gelir. Başka herhangi bir hata (örneğin permission denied) bunu bilemeyeceğiniz anlamına gelir, bu yüzden onu "yok" olarak ele almak yerine ayrıca işleyin.

İlgili kavramlar