Rustプログラミングにおいて、ファイル操作はアプリケーション開発の基盤となる重要なスキルです。Rustの標準ライブラリであるstd::fsは、シンプルで使いやすいインターフェースを提供し、ファイルの読み取り、書き込み、削除、ディレクトリ操作など、多様なタスクを効率的に実行できます。本記事では、std::fsを活用してファイル操作を学び、実践的なプログラムの構築方法を習得します。これにより、Rust初心者から中級者へとステップアップするための確固たる基礎を築けるでしょう。
`std::fs`とは
Rustの標準ライブラリstd::fsは、ファイルやディレクトリを操作するための便利な関数群を提供するモジュールです。これを使用することで、次のようなタスクを簡単に実現できます。
主な機能
std::fsには以下のような機能が含まれています。
ファイル操作
- ファイルの読み取り（例:
fs::read_to_string） - ファイルへの書き込み（例:
fs::write） - ファイルの追記や更新（例:
OpenOptionsを使用）
ディレクトリ操作
- ディレクトリの作成（例:
fs::create_dir） - ファイル一覧の取得（例:
fs::read_dir） - ディレクトリやその中身の削除（例:
fs::remove_dir_all）
`std::fs`の特徴
- シンプルなAPI設計: Rustの安全性を活かし、直感的に使える関数が多い。
- クロスプラットフォーム: WindowsやLinuxなど、様々な環境で一貫した動作を保証。
- 高い信頼性: ファイル操作のエラーも明示的にハンドリング可能。
コード例
次のコードは、std::fsを使った簡単なファイル操作の例です。
use std::fs;
fn main() -> std::io::Result<()> {
// ファイルにデータを書き込む
fs::write("example.txt", "Hello, Rust!")?;
// ファイルを読み取る
let contents = fs::read_to_string("example.txt")?;
println!("ファイル内容: {}", contents);
Ok(())
}このように、std::fsは、直感的でありながら強力なファイル操作のツールを提供しており、Rust開発者にとって欠かせないモジュールです。
ファイルを読み取る方法
Rustでは、std::fsモジュールを使用して簡単にファイルを読み取ることができます。特に、fs::read_to_string関数を利用すると、テキストファイルの内容を一度に文字列として取得できます。
`fs::read_to_string`を使った基本的な読み取り
fs::read_to_string関数は、指定したパスのテキストファイルを読み取るために使用します。以下にその使い方を示します。
use std::fs;
fn main() -> std::io::Result<()> {
// ファイルパスを指定して内容を読み取る
let contents = fs::read_to_string("example.txt")?;
println!("ファイル内容:\n{}", contents);
Ok(())
}このコードは、example.txtの内容を読み取り、コンソールに表示します。
ポイント: ファイルが存在しない場合やアクセス権限がない場合はエラーが発生するため、適切にエラーハンドリングを行う必要があります。
バイナリファイルを読み取る方法
バイナリデータを扱いたい場合は、fs::readを使用します。この関数はファイルの内容をVec<u8>として返します。
use std::fs;
fn main() -> std::io::Result<()> {
// バイナリデータを読み取る
let data = fs::read("example.bin")?;
println!("バイナリデータ: {:?}", data);
Ok(())
}この例では、バイナリファイルの内容をベクタ形式で取得します。
逐次的な読み取り
大きなファイルを扱う場合は、std::io::BufReaderを使用して効率的にデータを逐次読み取ることができます。
use std::fs::File;
use std::io::{self, BufRead};
fn main() -> io::Result<()> {
let file = File::open("large_file.txt")?;
let reader = io::BufReader::new(file);
// 1行ずつ読み取る
for line in reader.lines() {
println!("{}", line?);
}
Ok(())
}この方法は、大容量のファイルを扱う際にメモリ使用量を抑えられる点で有用です。
エラーハンドリングの重要性
ファイルを読み取る際には、以下のようなエラーが発生する可能性があります。
- ファイルが存在しない場合
- アクセス権限が不足している場合
- ファイルが破損している場合
これらのエラーを適切に処理することで、プログラムの堅牢性を高めることができます。
まとめ
std::fsモジュールを利用すれば、テキストファイルやバイナリファイルの読み取りが簡単に行えます。また、適切なエラーハンドリングと効率的な方法を選択することで、より良いプログラムを構築できます。
ファイルへの書き込み
Rustでは、std::fsモジュールを使用して簡単にファイルへの書き込みができます。特にfs::write関数を使えば、テキストやバイナリデータを一度にファイルに保存することが可能です。
`fs::write`を使った基本的な書き込み
fs::write関数は、指定したパスにデータを書き込むシンプルな方法を提供します。この関数はファイルが存在しない場合は新規作成し、存在する場合は内容を上書きします。
use std::fs;
fn main() -> std::io::Result<()> {
// ファイルに文字列データを書き込む
fs::write("example.txt", "Hello, Rust!")?;
println!("ファイルに書き込みました。");
Ok(())
}このコードは、example.txtにHello, Rust!という内容を書き込みます。
バイナリデータの書き込み
バイナリデータもfs::writeで簡単に書き込むことができます。
use std::fs;
fn main() -> std::io::Result<()> {
let binary_data = vec![0xDE, 0xAD, 0xBE, 0xEF];
fs::write("example.bin", binary_data)?;
println!("バイナリデータを書き込みました。");
Ok(())
}この例では、example.binにバイナリデータを保存しています。
ファイルを作成して書き込む
fs::Fileとstd::io::Writeトレイトを利用すると、さらに細かい制御が可能です。
use std::fs::File;
use std::io::Write;
fn main() -> std::io::Result<()> {
let mut file = File::create("output.txt")?;
file.write_all(b"Rustでのファイル書き込み")?;
println!("ファイルを作成して書き込みました。");
Ok(())
}この方法は、追記や逐次的な書き込みを行う際にも活用できます。
エラーハンドリング
ファイルへの書き込みでは以下のようなエラーが発生する可能性があります。
- 書き込み対象のディレクトリが存在しない。
- 書き込み権限がない。
- ディスク容量が不足している。
これらを考慮し、適切にエラーハンドリングを行いましょう。
応用: ファイルの一括書き込み
複数のファイルを一括で書き込む場合も簡単に処理できます。
use std::fs;
fn main() -> std::io::Result<()> {
let files = vec!["file1.txt", "file2.txt", "file3.txt"];
let data = "共通のデータ";
for file in files {
fs::write(file, data)?;
println!("{} に書き込みました。", file);
}
Ok(())
}このコードは、複数のファイルに同じデータを書き込む場合の例です。
まとめ
std::fsモジュールのfs::writeは、簡単かつ効率的なファイル書き込みを可能にします。さらに、FileとWriteを利用すれば、細かい制御も実現可能です。用途に応じた適切な方法を選び、Rustでのファイル書き込みをマスターしましょう。
ファイルを追記する方法
Rustでは、std::fs::OpenOptionsを使用することで、既存のファイルにデータを追記することができます。この方法は、ログファイルや履歴の保存など、既存データを保持したまま新しい情報を追加したい場合に便利です。
`OpenOptions`を使った追記
OpenOptionsは、ファイルの読み取り、書き込み、追記、作成などの操作モードを柔軟に指定するために使用します。以下は追記の基本的なコード例です。
use std::fs::OpenOptions;
use std::io::Write;
fn main() -> std::io::Result<()> {
// ファイルを開き、追記モードで書き込み
let mut file = OpenOptions::new()
.append(true) // 追記モードを有効にする
.create(true) // ファイルが存在しない場合は作成
.open("example.txt")?;
// 新しいデータを追記
file.write_all(b"新しい行を追記します。\n")?;
println!("ファイルにデータを追記しました。");
Ok(())
}このコードは、example.txtに新しい行を追加します。ファイルが存在しない場合は、自動的に作成されます。
複数行の追記
次の例では、複数のデータをループで追記しています。
use std::fs::OpenOptions;
use std::io::Write;
fn main() -> std::io::Result<()> {
let mut file = OpenOptions::new().append(true).create(true).open("log.txt")?;
// データを追記
for i in 1..=5 {
writeln!(file, "ログエントリ: {}", i)?;
}
println!("複数行を追記しました。");
Ok(())
}このコードは、log.txtに連続的なログエントリを追記します。
エラーハンドリングの注意点
追記処理でも以下のようなエラーが発生する可能性があります。
- ファイルがロックされている場合（他のプロセスが使用中）。
- 書き込み権限がない場合。
- ディスク容量が不足している場合。
適切なエラーメッセージを表示し、ユーザーにフィードバックを与えることが重要です。
ユースケース: ログファイルの管理
追記操作は、ログファイルの生成や更新に非常に便利です。以下はログエントリを日時付きで追記する例です。
use std::fs::OpenOptions;
use std::io::Write;
use chrono::Local;
fn main() -> std::io::Result<()> {
let mut file = OpenOptions::new().append(true).create(true).open("application.log")?;
// 現在時刻を取得してログエントリを作成
let timestamp = Local::now();
writeln!(file, "[{}] アプリケーションが起動しました。", timestamp)?;
println!("ログファイルに追記しました。");
Ok(())
}このコードは、chronoクレートを使用して現在時刻を取得し、ログファイルに追記します。
まとめ
OpenOptionsを活用すれば、既存のファイルにデータを追記することが簡単にできます。ログファイルやデータ履歴の管理など、追記操作は多くの実用的な場面で役立ちます。適切なエラーハンドリングを行いながら、安全で効率的なファイル追記を実現しましょう。
ファイルの存在確認と削除
Rustでは、std::fsモジュールを使ってファイルの存在確認や削除を簡単に行うことができます。これらの操作は、ファイルを安全に扱うための重要なステップです。
ファイルの存在確認
std::path::Pathを使用すると、ファイルやディレクトリの存在を確認できます。以下はその基本的な例です。
use std::path::Path;
fn main() {
let path = Path::new("example.txt");
if path.exists() {
println!("ファイルは存在します。");
} else {
println!("ファイルは存在しません。");
}
}ポイント:
exists()メソッドは、ファイルまたはディレクトリの存在を確認します。- 存在確認は削除操作を行う前にチェックする場合などに便利です。
ファイルの削除
ファイルを削除するには、fs::remove_file関数を使用します。次のコードは、ファイルの存在を確認してから削除する例です。
use std::fs;
use std::path::Path;
fn main() -> std::io::Result<()> {
let path = Path::new("example.txt");
if path.exists() {
fs::remove_file(path)?;
println!("ファイルを削除しました。");
} else {
println!("削除するファイルは存在しません。");
}
Ok(())
}このコードでは、example.txtが存在する場合に削除を実行します。
ディレクトリの削除
ディレクトリを削除する場合、以下の関数を使用します。
- 空のディレクトリを削除:
fs::remove_dir - 中身を含むディレクトリを削除:
fs::remove_dir_all
use std::fs;
fn main() -> std::io::Result<()> {
// 空のディレクトリを削除
fs::remove_dir("empty_dir")?;
println!("空のディレクトリを削除しました。");
// 中身を含むディレクトリを削除
fs::remove_dir_all("non_empty_dir")?;
println!("中身を含むディレクトリを削除しました。");
Ok(())
}エラーハンドリング
削除操作では次のようなエラーが発生する可能性があります。
- ファイルやディレクトリが存在しない場合。
- 権限が不足している場合。
- 他のプロセスがファイルやディレクトリを使用している場合。
これらのエラーを適切にキャッチし、ユーザーに通知することが重要です。
応用例: 安全なファイル削除
次のコードは、削除前に確認を行う例です。
use std::fs;
use std::io;
use std::io::Write;
fn main() -> std::io::Result<()> {
let file_name = "example.txt";
println!("{} を削除しますか？ (y/n)", file_name);
let mut input = String::new();
io::stdin().read_line(&mut input)?;
if input.trim().eq_ignore_ascii_case("y") {
if std::path::Path::new(file_name).exists() {
fs::remove_file(file_name)?;
println!("ファイルを削除しました。");
} else {
println!("指定されたファイルは存在しません。");
}
} else {
println!("削除をキャンセルしました。");
}
Ok(())
}このプログラムは、削除前にユーザーの確認を求めることで、誤操作を防ぎます。
まとめ
ファイルやディレクトリの存在確認と削除は、プログラムの堅牢性を高める重要な機能です。std::fsとstd::pathを組み合わせて安全に操作を行い、エラーハンドリングを徹底することで、柔軟で信頼性の高いファイル管理が実現できます。
ディレクトリ操作の基本
Rustでは、std::fsモジュールを使用してディレクトリを作成、一覧取得、削除など、さまざまな操作が行えます。これらの操作は、ファイル管理を効率化し、柔軟なプログラム設計を可能にします。
ディレクトリの作成
新しいディレクトリを作成するには、fs::create_dir関数を使用します。また、親ディレクトリが存在しない場合に作成を許可するfs::create_dir_allも利用できます。
use std::fs;
fn main() -> std::io::Result<()> {
// 単一のディレクトリを作成
fs::create_dir("new_dir")?;
println!("ディレクトリ 'new_dir' を作成しました。");
// 階層構造のディレクトリを作成
fs::create_dir_all("parent_dir/child_dir")?;
println!("ディレクトリ 'parent_dir/child_dir' を作成しました。");
Ok(())
}ポイント:
create_dirは親ディレクトリが存在しない場合にエラーを返します。create_dir_allは階層全体を一度に作成します。
ディレクトリ内の一覧取得
ディレクトリ内のファイルやサブディレクトリを取得するには、fs::read_dirを使用します。
use std::fs;
fn main() -> std::io::Result<()> {
let entries = fs::read_dir(".")?; // カレントディレクトリを読み取る
for entry in entries {
let entry = entry?;
println!("名前: {:?}", entry.file_name());
}
Ok(())
}このコードは、カレントディレクトリ内のすべてのエントリ（ファイルやディレクトリ）を取得して表示します。
ディレクトリの削除
ディレクトリを削除するには、次の関数を使用します。
- 空のディレクトリを削除:
fs::remove_dir - 中身を含むディレクトリを削除:
fs::remove_dir_all
use std::fs;
fn main() -> std::io::Result<()> {
// 空のディレクトリを削除
fs::remove_dir("empty_dir")?;
println!("空のディレクトリを削除しました。");
// 中身を含むディレクトリを削除
fs::remove_dir_all("parent_dir")?;
println!("中身を含むディレクトリを削除しました。");
Ok(())
}注意:remove_dir_allはディレクトリ内のすべてのファイルとサブディレクトリを再帰的に削除します。誤操作を防ぐために、使用する際は慎重に取り扱いましょう。
ディレクトリ操作でのエラーハンドリング
ディレクトリ操作では以下のエラーが発生する可能性があります。
- 作成しようとしたディレクトリがすでに存在する。
- 読み取ろうとしたディレクトリが見つからない。
- 削除権限が不足している。
これらを考慮し、エラーメッセージを適切に処理することで、プログラムの信頼性を向上させます。
応用例: ファイル構造の一覧表示
次のコードは、指定したディレクトリ内のファイルとサブディレクトリを再帰的に表示します。
use std::fs;
use std::path::Path;
fn list_dir(path: &Path, depth: usize) -> std::io::Result<()> {
if path.is_dir() {
for entry in fs::read_dir(path)? {
let entry = entry?;
let entry_path = entry.path();
println!("{:indent$}{}", "", entry_path.display(), indent = depth * 2);
if entry_path.is_dir() {
list_dir(&entry_path, depth + 1)?; // 再帰的に表示
}
}
}
Ok(())
}
fn main() -> std::io::Result<()> {
list_dir(Path::new("."), 0)?;
Ok(())
}このコードは、カレントディレクトリ内のファイル構造を階層的に表示します。
まとめ
Rustのstd::fsモジュールは、ディレクトリ操作における強力で柔軟なツールを提供します。ディレクトリの作成、一覧取得、削除などの基本操作を理解し、安全に運用することで、効率的なファイル管理を実現できます。
エラーハンドリング
Rustでのファイル操作にはエラーがつきものです。たとえば、ファイルが存在しない、権限が不足している、ディスク容量が不足しているなどの問題が挙げられます。std::fsモジュールを使う際には、適切なエラーハンドリングを行うことで、プログラムの堅牢性を向上させることができます。
Rustにおけるエラーハンドリングの基本
Rustでは、エラーをResult型で返します。Resultは以下の2つの値を持つ列挙型です。
Ok(value)：処理が成功した場合の結果を含む。Err(error)：エラー情報を含む。
次のようにエラーを処理できます。
use std::fs;
fn main() {
match fs::read_to_string("example.txt") {
Ok(contents) => println!("ファイル内容:\n{}", contents),
Err(error) => eprintln!("ファイルを読み取れませんでした: {}", error),
}
}このコードは、ファイルが存在しない場合や読み取り権限がない場合にエラーメッセージを表示します。
`?`演算子を使った簡潔なエラーハンドリング
Rustでは?演算子を使用することで、エラーチェックを簡潔に記述できます。
use std::fs;
fn main() -> std::io::Result<()> {
let contents = fs::read_to_string("example.txt")?;
println!("ファイル内容:\n{}", contents);
Ok(())
}ポイント:
?演算子は、エラーが発生した場合に即座に関数からエラーを返します。- より読みやすく、簡潔なコードを記述できます。
特定のエラーを処理する
特定のエラーだけを処理したい場合は、matchやif letを使用します。
use std::fs;
fn main() {
let result = fs::read_to_string("example.txt");
match result {
Ok(contents) => println!("ファイル内容:\n{}", contents),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
eprintln!("ファイルが見つかりませんでした。")
}
Err(error) => eprintln!("エラーが発生しました: {}", error),
}
}このコードは、ファイルが存在しない場合のエラーを特別に扱っています。
エラーをログとして記録する
エラーをコンソールに表示するだけでなく、ログファイルに記録することもできます。
use std::fs::{self, OpenOptions};
use std::io::Write;
fn log_error(error: &str) {
let mut log_file = OpenOptions::new()
.append(true)
.create(true)
.open("error.log")
.expect("ログファイルを開けませんでした。");
writeln!(log_file, "{}", error).expect("ログに書き込めませんでした。");
}
fn main() {
let result = fs::read_to_string("example.txt");
if let Err(error) = result {
let error_message = format!("エラーが発生しました: {}", error);
eprintln!("{}", error_message);
log_error(&error_message);
}
}このプログラムは、エラー情報をerror.logファイルに記録します。
エラーハンドリングの応用: リトライ機能
一部のエラー（例えば、ネットワーク接続に関連するエラー）では、リトライを試みることが有効です。
use std::fs;
use std::thread;
use std::time::Duration;
fn read_with_retry(file: &str, retries: u32) -> Result<String, std::io::Error> {
let mut attempts = 0;
while attempts < retries {
match fs::read_to_string(file) {
Ok(contents) => return Ok(contents),
Err(_) if attempts < retries - 1 => {
println!("リトライ中... ({}回目)", attempts + 1);
thread::sleep(Duration::from_secs(1));
attempts += 1;
}
Err(error) => return Err(error),
}
}
Err(std::io::Error::new(std::io::ErrorKind::Other, "最大リトライ回数に達しました"))
}
fn main() {
match read_with_retry("example.txt", 3) {
Ok(contents) => println!("ファイル内容:\n{}", contents),
Err(error) => eprintln!("最終的に失敗しました: {}", error),
}
}このコードは、3回までファイル読み取りをリトライする例です。
まとめ
Rustでは、安全性を重視したエラーハンドリングの仕組みが提供されています。Result型や?演算子を活用し、適切なエラー処理を実装することで、予期せぬトラブルを防ぎ、プログラムの信頼性を高めることができます。ログ記録やリトライ機能を組み合わせることで、さらに応用範囲を広げられます。
応用例: 設定ファイルの操作
設定ファイルの読み書きは、アプリケーションの柔軟な構成を可能にする重要な機能です。Rustでは、std::fsを使用して、設定ファイルの操作を簡単に行えます。ここでは、JSON形式の設定ファイルを操作する例を中心に解説します。
JSON形式の設定ファイルの読み取り
設定ファイルをJSON形式で保存すると、キーと値のペアで簡単にデータを管理できます。以下のコードは、JSONファイルを読み取る例です。
use std::fs;
use serde::Deserialize;
#[derive(Deserialize, Debug)]
struct Config {
app_name: String,
version: String,
debug: bool,
}
fn main() -> std::io::Result<()> {
// JSONファイルを読み取る
let config_data = fs::read_to_string("config.json")?;
let config: Config = serde_json::from_str(&config_data)
.expect("設定ファイルのパースに失敗しました");
println!("設定内容: {:?}", config);
Ok(())
}ポイント:
serdeとserde_jsonクレートを利用して、JSONをRust構造体にデコードします。- エラーが発生した場合は適切にハンドリングします。
例: config.json
{
"app_name": "MyRustApp",
"version": "1.0.0",
"debug": true
}設定ファイルへの書き込み
設定ファイルを更新する場合は、構造体をJSON形式にエンコードして保存します。
use std::fs;
use serde::Serialize;
#[derive(Serialize)]
struct Config {
app_name: String,
version: String,
debug: bool,
}
fn main() -> std::io::Result<()> {
// 設定データを構造体で定義
let config = Config {
app_name: "MyRustApp".to_string(),
version: "1.1.0".to_string(),
debug: false,
};
// JSON形式に変換してファイルに書き込む
let config_data = serde_json::to_string_pretty(&config)
.expect("設定データのシリアライズに失敗しました");
fs::write("config.json", config_data)?;
println!("設定ファイルを更新しました。");
Ok(())
}ポイント:
serde_json::to_string_prettyを使うと、見やすいフォーマットでJSONを生成できます。- ファイルの書き込みは
fs::writeで簡単に行えます。
動的な設定更新
ユーザーがアプリケーションの設定を実行時に変更できるようにする場合、ファイルの読み書きを組み合わせる必要があります。
use std::fs;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
struct Config {
app_name: String,
version: String,
debug: bool,
}
fn load_config(path: &str) -> Config {
let config_data = fs::read_to_string(path)
.expect("設定ファイルを読み取れませんでした");
serde_json::from_str(&config_data).expect("設定ファイルのパースに失敗しました")
}
fn save_config(path: &str, config: &Config) {
let config_data = serde_json::to_string_pretty(config)
.expect("設定データのシリアライズに失敗しました");
fs::write(path, config_data).expect("設定ファイルの書き込みに失敗しました");
}
fn main() {
let path = "config.json";
// 設定ファイルを読み取る
let mut config = load_config(path);
println!("現在の設定: {:?}", config);
// 設定を更新
config.debug = !config.debug; // デバッグモードを反転
println!("デバッグモードを反転しました: {:?}", config);
// 設定ファイルを保存
save_config(path, &config);
println!("設定を保存しました。");
}ポイント:
- 設定を柔軟に読み書きできるよう、関数を分離して再利用性を高めています。
- デバッグモードを反転する簡単な例を示しています。
応用: YAML形式の設定ファイル
JSON以外に、YAML形式を利用することも一般的です。Rustでは、serde_yamlクレートを使用して同様の操作が可能です。
use std::fs;
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
struct Config {
app_name: String,
version: String,
debug: bool,
}
fn main() -> std::io::Result<()> {
let path = "config.yaml";
// 設定を読み込む
let config_data = fs::read_to_string(path)?;
let config: Config = serde_yaml::from_str(&config_data)
.expect("設定ファイルのパースに失敗しました");
println!("YAML設定内容: {:?}", config);
// 設定を更新して書き込む
let updated_config = Config {
app_name: "UpdatedRustApp".to_string(),
version: "2.0.0".to_string(),
debug: true,
};
let updated_data = serde_yaml::to_string(&updated_config)
.expect("設定データのシリアライズに失敗しました");
fs::write(path, updated_data)?;
println!("設定を更新しました。");
Ok(())
}まとめ
Rustで設定ファイルを操作する方法を理解すれば、アプリケーションの柔軟性を高められます。JSONやYAMLなどのフォーマットを活用し、serdeライブラリを使用して安全かつ効率的にデータを読み書きしましょう。これにより、ユーザー体験を向上させる高度な構成管理が実現できます。
まとめ
本記事では、Rustのstd::fsを活用したファイル操作について、基本的な読み書き方法から、追記、削除、ディレクトリ管理、エラーハンドリング、そして応用例として設定ファイルの操作までを詳しく解説しました。Rustの標準ライブラリは、シンプルながらも強力で、安全性と効率性を兼ね備えた設計がされています。
特に、std::fsを使ったファイル操作は、システムプログラムやアプリケーション開発の基盤となるスキルです。適切なエラーハンドリングを実装し、応用例で示したようにJSONやYAML形式の設定ファイルを活用することで、柔軟性と拡張性のあるプログラムを作成できます。
これらの知識を活かして、実践的なプロジェクトに取り組み、Rustでのファイル操作スキルをさらに向上させていきましょう！
コメント