תיעוד 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() אחרי הלולאה. שורות ארוכות מ-64 KB גורמות לסורק להיכשל עם token too long, אלא אם מגדילים את ה-buffer שלו עם sc.Buffer.

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 מבחינה ביניהם.
מגבלת השורה של 64 KB. כברירת מחדל, שורה בודדת ארוכה מ-64 KB עוצרת את הסורק עם bufio.Scanner: token too long. לקבצים עם שורות ארוכות (JSON מכווץ, חלק מהלוגים), הגדילו את המגבלה לפני הלולאה: sc.Buffer(make([]byte, 1024*1024), 10*1024*1024).
יחידות אחרות. sc.Split(bufio.ScanWords) מחזירה מילים; bufio.ScanRunes מחזירה תווים.

לקריאת stream במקטעים בגודל קבוע במקום בשורות, השתמשו ב-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() לבדו יכול להסתיר נתונים שאבדו. בקבצים שאתם כותבים אליהם, בדקו את Close במפורש כמו ש-appendLine עושה. בקבצים שרק קוראים מהם, 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 מיועדת לנתיבים שמופרדים בלוכסן, כמו URLs.

Go 1.24 הוסיפה גם את os.Root (os.OpenRoot(dir)), שפותח קבצים רק בתוך תיקייה אחת ודוחה נתיבים שבורחים ממנה עם .. או עם symlinks. השתמשו בו כששמות הקבצים מגיעים ממשתמשים.

טעויות נפוצות

לא לבדוק שגיאות. כל אחת מהקריאות האלה יכולה להיכשל. קובץ שלא נפתח הוא nil, וכל Read, Write או Close מאוחרים יותר עליו מחזירים invalid argument, מה שמסתיר את הסיבה האמיתית (הקובץ היה חסר, או שההרשאה נדחתה).
שכחת sc.Err() אחרי לולאת סריקה. שגיאת קריאה נראית כמו סוף קובץ.
שכחת Flush על bufio.Writer. סוף הקובץ חסר.
התעלמות מהשגיאה של Close אחרי כתיבה. שגיאות כתיבה עשויות להתגלות רק שם.
defer f.Close() בתוך לולאה על הרבה קבצים. הקבצים נשארים פתוחים עד שהפונקציה חוזרת, ועלולים להיגמר ה-file descriptors. העבירו את גוף הלולאה לפונקציה כדי שכל קובץ ייסגר בכל איטרציה.
הרשאות שנכתבות בעשרוני. 644 אינו 0o644. Go קוראת את 644 כמספר עשרוני, שהוא 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() אחרי הלולאה. שורות ארוכות מ-64 KB גורמות לסורק להיכשל עם token too long, אלא אם מגדילים את ה-buffer שלו עם sc.Buffer.

איך מוסיפים לסוף קובץ ב-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) פירושה שאי אפשר לדעת, ולכן טפלו בה בנפרד ואל תתייחסו אליה כאל "לא קיים".

מושגים קשורים