Go言語でファイルに1行ずつ書き込む方法について解説

package main
import (
	"fmt"
	"os"
)
func main() {
	// sample.txtというファイルを作成します
	file, err := os.Create("sample.txt")
	if err != nil {
		fmt.Println("ファイル作成エラー:", err)
		return
	}
	// ファイルをクローズしてリソースを解放します
	err = file.Close()
	if err != nil {
		fmt.Println("ファイルクローズエラー:", err)
		return
	}
	fmt.Println("ファイルを正常に作成・クローズしました")
}

ファイルを正常に作成・クローズしました

package main
import (
	"bufio"
	"fmt"
	"os"
)
func main() {
	// ファイルをオープンまたは作成します
	file, err := os.Create("buffered_sample.txt")
	if err != nil {
		fmt.Println("ファイル作成エラー:", err)
		return
	}
	defer file.Close()
	// bufio.NewWriterでファイルにバッファを書き出すためのWriterを生成します
	writer := bufio.NewWriter(file)
	// バッファ経由で文字列を書き込みます
	_, err = writer.WriteString("これはbufioを利用した書き込み例です\n")
	if err != nil {
		fmt.Println("書き込みエラー:", err)
		return
	}
	// バッファの内容をファイルに確実に書き出します
	err = writer.Flush()
	if err != nil {
		fmt.Println("Flushエラー:", err)
		return
	}
	fmt.Println("bufioを利用したファイル書き込みが完了しました")
}

bufioを利用したファイル書き込みが完了しました

package main
import (
	"fmt"
	"os"
)
func main() {
	// sample.txtを作成・書き込みモードでオープンします
	file, err := os.OpenFile("sample.txt", os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println("ファイルオープンエラー:", err)
		return
	}
	// 関数終了時にファイルをクローズします
	defer file.Close()
	// ファイルが正常にオープンしたことを確認するメッセージ
	fmt.Println("ファイルを正常にオープンしました")
}

ファイルを正常にオープンしました

package main
import (
	"fmt"
	"os"
)
func main() {
	// ファイルを作成する際のパーミッションは、所有者が読み書き可能、
	// グループとその他が読み取り可能な0644を設定します
	file, err := os.OpenFile("sample.txt", os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println("ファイルオープンエラー:", err)
		return
	}
	defer file.Close()
	fmt.Println("パーミッション設定を含むファイルオープンに成功しました")
}

パーミッション設定を含むファイルオープンに成功しました

package main
import (
	"bufio"
	"fmt"
	"os"
)
func main() {
	// buffered_sample.txtというファイルを作成します
	file, err := os.Create("buffered_sample.txt")
	if err != nil {
		fmt.Println("ファイル作成エラー:", err)
		return
	}
	defer file.Close()
	// bufio.NewWriterでバッファを作成します
	writer := bufio.NewWriter(file)
	// 1行ずつ文字列を書き込みます
	_, err = writer.WriteString("1行目のデータを書き込みます\n")
	if err != nil {
		fmt.Println("書き込みエラー:", err)
		return
	}
	fmt.Println("WriteStringメソッドでの書き込みが完了しました")
}

WriteStringメソッドでの書き込みが完了しました

package main
import (
	"bufio"
	"fmt"
	"os"
)
func main() {
	// append_sample.txtというファイルを作成します
	file, err := os.Create("append_sample.txt")
	if err != nil {
		fmt.Println("ファイル作成エラー:", err)
		return
	}
	defer file.Close()
	writer := bufio.NewWriter(file)
	_, err = writer.WriteString("1行目のデータを書き込みます\n")
	if err != nil {
		fmt.Println("書き込みエラー:", err)
		return
	}
	// 必ずFlushメソッドでバッファの内容をファイルに書き出します
	err = writer.Flush()
	if err != nil {
		fmt.Println("Flushエラー:", err)
		return
	}
	fmt.Println("Flushメソッドでの書き込みが完了しました")
}

Flushメソッドでの書き込みが完了しました

package main
import (
	"fmt"
	"os"
)
func main() {
	// ファイルを追記モードでオープンします。ファイルが存在しない場合には作成されます。
	file, err := os.OpenFile("append_mode.txt", os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)
	if err != nil {
		fmt.Println("ファイルオープンエラー:", err)
		return
	}
	defer file.Close()
	// 追記する文字列をファイルに書き込みます
	_, err = file.WriteString("追記モードで書き込みます\n")
	if err != nil {
		fmt.Println("書き込みエラー:", err)
		return
	}
	fmt.Println("os.OpenFileを利用した書き込み設定が完了しました")
}

os.OpenFileを利用した書き込み設定が完了しました

package main
import (
	"fmt"
	"os"
)
func main() {
	// ファイルをオープンする際にエラーチェックを行います
	file, err := os.OpenFile("error_check.txt", os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println("ファイルオープンエラー:", err)
		return
	}
	defer file.Close()
	// 書き込み時のエラーも確認します
	_, err = file.WriteString("エラー確認のためのサンプルデータです\n")
	if err != nil {
		fmt.Println("書き込みエラー:", err)
		return
	}
	fmt.Println("ファイル操作中のエラーを正常に検知しました")
}

ファイル操作中のエラーを正常に検知しました

package main
import (
	"fmt"
	"os"
)
func main() {
	// ファイルオープン時にエラー確認を行います
	file, err := os.OpenFile("error_pattern.txt", os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println("ファイルオープン失敗:", err)
		return
	}
	defer file.Close()
	// 書き込み処理中のエラーチェック
	_, err = file.WriteString("エラーパターンのサンプルデータ\n")
	if err != nil {
		fmt.Println("書き込み失敗:", err)
		return
	}
	fmt.Println("エラー処理の基本パターンが正常に動作しました")
}

エラー処理の基本パターンが正常に動作しました

package main
import (
	"bufio"
	"fmt"
	"os"
)
func main() {
	file, err := os.Create("buffer_efficiency.txt")
	if err != nil {
		fmt.Println("ファイル作成エラー:", err)
		return
	}
	defer file.Close()
	writer := bufio.NewWriter(file)
	// ループで複数行のデータを書き込みます
	for i := 1; i <= 5; i++ {
		line := fmt.Sprintf("行%dのデータです\n", i)
		_, err := writer.WriteString(line)
		if err != nil {
			fmt.Println("書き込みエラー:", err)
			return
		}
	}
	// まとめてバッファのデータをファイルに書き出します
	if err := writer.Flush(); err != nil {
		fmt.Println("Flushエラー:", err)
		return
	}
	fmt.Println("効率的なバッファ活用で全データ書き込み完了")
}

効率的なバッファ活用で全データ書き込み完了

package main
import (
	"fmt"
	"os"
	"time"
)
func writeFile(filename, data string) {
	// ファイルを作成またはオープンして書き込む処理
	file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println(filename, "のオープンエラー:", err)
		return
	}
	defer file.Close()
	_, err = file.WriteString(data)
	if err != nil {
		fmt.Println(filename, "の書き込みエラー:", err)
		return
	}
	fmt.Println(filename, "への書き込みが完了しました")
}
func main() {
	// goroutineを用いて複数のファイル書き込みを並行処理します
	go writeFile("file1.txt", "ファイル1のデータです\n")
	go writeFile("file2.txt", "ファイル2のデータです\n")
	// goroutineの処理待ちのためにスリープを入れます
	time.Sleep(500 * time.Millisecond)
	fmt.Println("並行処理による各ファイルへの書き込みが完了しました")
}

file1.txt への書き込みが完了しました
file2.txt への書き込みが完了しました
並行処理による各ファイルへの書き込みが完了しました

package main
import (
	"fmt"
	"os"
	"sync"
)
func concurrentWrite(wg *sync.WaitGroup, filename, data string) {
	// goroutineの終了を通知するためにDoneを呼びます
	defer wg.Done()
	file, err := os.OpenFile(filename, os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Println(filename, "のオープンエラー:", err)
		return
	}
	defer file.Close()
	_, err = file.WriteString(data)
	if err != nil {
		fmt.Println(filename, "の書き込みエラー:", err)
		return
	}
	fmt.Println(filename, "への書き込みが完了しました")
}
func main() {
	var wg sync.WaitGroup
	// 書き込みを行うgoroutineの数を設定します
	files := []struct {
		name string
		data string
	}{
		{"concurrent1.txt", "並行処理 1 のデータ\n"},
		{"concurrent2.txt", "並行処理 2 のデータ\n"},
	}
	wg.Add(len(files))
	for _, fileItem := range files {
		// 各goroutineにてファイル書き込みを実施します
		go concurrentWrite(&wg, fileItem.name, fileItem.data)
	}
	// 全てのgoroutineの終了を待ちます
	wg.Wait()
	fmt.Println("syncパッケージを利用した全goroutineの書き込みが完了しました")
}

concurrent1.txt への書き込みが完了しました
concurrent2.txt への書き込みが完了しました
syncパッケージを利用した全goroutineの書き込みが完了しました