Rustを使って効率的にバイナリファイルを読み書きする方法について解説します。バイナリファイルはテキストファイルとは異なり、データがそのままの形式で格納されるため、大容量データや特定のデータ構造を扱う際に有用です。Rustの標準ライブラリには、バイナリファイル操作を行うための関数が用意されており、std::fs::readやstd::fs::writeを活用すれば簡単にファイルの読み書きが可能です。
本記事では、バイナリファイルの基本概念から、Rustでの具体的な操作方法、エラーハンドリング、効率化のテクニック、さらには実際の応用例まで詳しく解説します。Rustを使ったファイル操作のスキルを高め、パフォーマンスの高いアプリケーション開発を目指しましょう。
Rustにおけるバイナリファイルとは
バイナリファイルとは、データがそのままのバイナリ形式（0と1のビット）で保存されているファイルのことです。テキストファイルと異なり、人間が直接読むことは難しいですが、データ構造や画像、音声、動画、圧縮データなど、あらゆる形式のデータを効率的に格納できます。
バイナリファイルの特徴
- 高効率なデータ保存：テキスト形式よりもデータが圧縮されて保存されるため、ファイルサイズが小さくなることが多い。
- 任意のデータ型を保存可能：構造体や数値データ、画像など、テキストでは扱えない形式のデータも保存できる。
- 高速アクセス：データがそのままの形式で保存されるため、読み書きが高速です。
バイナリファイルの用途
- 設定ファイルやデータベース：アプリケーションが内部で使用するデータを効率的に保存。
- メディアファイル：画像、音声、動画ファイルの格納。
- 圧縮ファイル：ZIPやRARなどの圧縮形式のファイル。
- ネットワーク通信：効率的なデータ送受信を行うためにバイナリ形式が利用されます。
Rustでは、標準ライブラリを利用してバイナリファイルを簡単に読み書きできます。次項では、具体的なファイル操作の手順について解説します。
バイナリファイル読み込みの基本操作
Rustでは、標準ライブラリのstd::fs::read関数を使って、バイナリファイルを簡単に読み込むことができます。バイナリファイルを読み込む際には、ファイル全体をバイト列（Vec<u8>）として取得します。
`std::fs::read`の基本的な使い方
以下は、std::fs::readを使用してバイナリファイルを読み込む基本的な例です。
use std::fs;
fn main() -> std::io::Result<()> {
let file_path = "example.bin";
// バイナリファイルを読み込む
let data = fs::read(file_path)?;
// 読み込んだデータの内容を確認
println!("{:?}", data);
Ok(())
}コードの解説
fs::read関数：指定したパスのファイルを読み込み、Vec<u8>として返します。- エラーハンドリング：
?演算子を使ってエラーを呼び出し元に伝播します。 - 読み込んだデータの確認：バイト列として取得したデータをデバッグ出力で確認します。
バイナリデータの処理
読み込んだバイト列は、そのまま処理するか、データ型に変換して使用します。例えば、数値データとして解釈するには、以下のようにfrom_le_bytesやfrom_be_bytesを利用します。
fn main() -> std::io::Result<()> {
let data = fs::read("numbers.bin")?;
if data.len() >= 4 {
let num = u32::from_le_bytes([data[0], data[1], data[2], data[3]]);
println!("数値: {}", num);
}
Ok(())
}注意点
- ファイルパスの確認：読み込むファイルが存在するか事前に確認しましょう。
- エラーハンドリング：ファイルが見つからない場合やアクセス権がない場合にエラーが発生するため、適切なエラーハンドリングが必要です。
- 大容量ファイル：非常に大きなファイルを読み込むとメモリ不足になる可能性があります。その場合は、ストリームを使用した読み込みを検討しましょう。
次項では、バイナリファイルへの書き込み方法について解説します。
バイナリファイル書き込みの基本操作
Rustでは、標準ライブラリのstd::fs::write関数を使用して、バイナリデータをファイルに書き込むことができます。write関数は、バイト列（&[u8]またはVec<u8>）を受け取り、指定したパスにデータを書き込みます。
`std::fs::write`の基本的な使い方
以下は、std::fs::writeを使用してバイナリファイルにデータを書き込む基本的な例です。
use std::fs;
fn main() -> std::io::Result<()> {
let file_path = "output.bin";
// 書き込むバイナリデータ
let data: Vec<u8> = vec![0x01, 0x02, 0x03, 0x04];
// バイナリデータを書き込む
fs::write(file_path, &data)?;
println!("データを書き込みました。");
Ok(())
}コードの解説
fs::write関数：指定したパスにバイト列をそのまま書き込みます。- 書き込むデータ：バイナリデータとして
Vec<u8>型を指定しています。 - エラーハンドリング：
?演算子で書き込み時のエラーを呼び出し元に伝播します。 - 書き込み確認：成功した場合にメッセージを出力します。
数値データを書き込む例
数値をバイナリ形式でファイルに書き込む場合、数値をバイト列に変換する必要があります。
use std::fs;
fn main() -> std::io::Result<()> {
let file_path = "numbers.bin";
// u32の数値をリトルエンディアン形式でバイト列に変換
let number: u32 = 12345;
let data = number.to_le_bytes();
// ファイルに書き込む
fs::write(file_path, &data)?;
println!("数値データを書き込みました。");
Ok(())
}エラーハンドリング
ファイル書き込み時に発生し得るエラーには、以下のようなものがあります。
- ファイルパスが不正：指定したパスが存在しない場合や書き込み権限がない場合。
- ディスク容量不足：書き込もうとしているファイルが大きすぎる場合。
エラーハンドリングの例：
use std::fs;
use std::io::{self, ErrorKind};
fn main() {
let result = fs::write("output.bin", &[0x00, 0x01, 0x02]);
match result {
Ok(_) => println!("データの書き込みに成功しました。"),
Err(e) => match e.kind() {
ErrorKind::PermissionDenied => println!("権限がありません。"),
ErrorKind::NotFound => println!("ファイルパスが見つかりません。"),
_ => println!("予期しないエラー: {:?}", e),
},
}
}注意点
- 既存ファイルの上書き：
fs::writeは既存のファイルを上書きします。上書きを避けたい場合は、事前にファイルの存在を確認しましょう。 - 大容量データの書き込み：大量のデータを書き込む際は、バッファリングを利用した書き込み方法も検討しましょう。
次項では、読み書きの具体的なコード例を紹介します。
バイナリファイル読み書きの例
ここでは、Rustを使ってバイナリファイルを読み書きする具体的なコード例を紹介します。バイナリデータとして数値や文字列を保存し、それを読み取るシナリオを解説します。
バイナリファイルにデータを書き込む
まず、std::fs::FileとWriteトレイトを使用して、バイナリファイルに数値と文字列を一緒に書き込みます。
use std::fs::File;
use std::io::{self, Write};
fn main() -> io::Result<()> {
let mut file = File::create("data.bin")?;
// 数値データをリトルエンディアンで書き込む
let number: u32 = 42;
file.write_all(&number.to_le_bytes())?;
// 文字列をバイト配列として書き込む
let text = "Hello, Rust!";
file.write_all(text.as_bytes())?;
println!("バイナリファイルにデータを書き込みました。");
Ok(())
}バイナリファイルからデータを読み込む
次に、書き込んだバイナリデータを読み込み、数値と文字列として処理します。
use std::fs::File;
use std::io::{self, Read};
fn main() -> io::Result<()> {
let mut file = File::open("data.bin")?;
let mut buffer = [0u8; 4]; // u32は4バイト
// 数値データを読み込む
file.read_exact(&mut buffer)?;
let number = u32::from_le_bytes(buffer);
println!("読み込んだ数値: {}", number);
// 残りのデータを読み込む（文字列部分）
let mut text = String::new();
file.read_to_string(&mut text)?;
println!("読み込んだ文字列: {}", text);
Ok(())
}コードの解説
- ファイル作成と書き込み
File::createで新しいバイナリファイルを作成します。write_allで数値と文字列をバイナリ形式でファイルに書き込みます。数値はリトルエンディアン形式に変換して保存します。
- ファイル読み込み
File::openで既存のバイナリファイルを開きます。- 数値部分は4バイトの配列として読み込み、
u32::from_le_bytesでリトルエンディアン形式のバイト列を数値に変換します。 - 残りのデータを文字列として読み込み、表示します。
出力結果
バイナリファイルにデータを書き込みました。
読み込んだ数値: 42
読み込んだ文字列: Hello, Rust!注意点
- データの順序：バイナリデータは書き込んだ順序で読み込む必要があります。
- エラーハンドリング：ファイル操作にはエラーが伴うため、
Result型を活用してエラー処理を行いましょう。 - エンディアン：異なるシステム間でデータをやり取りする場合、エンディアン（バイト順序）に注意が必要です。
次項では、バイナリファイル操作におけるエラーハンドリングについて詳しく解説します。
バイナリファイルのエラーハンドリング
バイナリファイルを操作する際には、さまざまなエラーが発生する可能性があります。RustではResult型と?演算子を使用して効率的にエラーハンドリングができます。本項では、ファイル読み書き時の代表的なエラーとその対処方法について解説します。
代表的なエラーとその対処法
- ファイルが存在しない場合
ファイルを読み込もうとして、指定したファイルが見つからない場合にエラーが発生します。
use std::fs::File;
use std::io;
fn main() {
match File::open("nonexistent.bin") {
Ok(_) => println!("ファイルを開きました。"),
Err(e) => println!("エラーが発生しました: {}", e),
}
}- 読み取り時のエラー
ファイルが破損していたり、予期しないデータ形式だった場合に読み取りエラーが発生します。
use std::fs::File;
use std::io::{self, Read};
fn main() -> io::Result<()> {
let mut file = File::open("data.bin")?;
let mut buffer = [0u8; 4];
if let Err(e) = file.read_exact(&mut buffer) {
println!("読み取りエラー: {}", e);
return Err(e);
}
println!("読み取り成功: {:?}", buffer);
Ok(())
}- 書き込み時のエラー
書き込み先のディレクトリが存在しない、または権限がない場合にエラーが発生します。
use std::fs::File;
use std::io::{self, Write};
fn main() -> io::Result<()> {
let mut file = File::create("/invalid_path/output.bin")?;
if let Err(e) = file.write_all(b"Hello") {
println!("書き込みエラー: {}", e);
return Err(e);
}
println!("書き込み成功");
Ok(())
}エラーの種類と`ErrorKind`
Rustのstd::io::ErrorKindを使用すると、エラーの種類を分類できます。
use std::fs::File;
use std::io::{self, ErrorKind};
fn main() {
match File::open("example.bin") {
Ok(_) => println!("ファイルを開きました。"),
Err(e) => match e.kind() {
ErrorKind::NotFound => println!("ファイルが見つかりません。"),
ErrorKind::PermissionDenied => println!("権限がありません。"),
_ => println!("その他のエラー: {}", e),
},
}
}エラーハンドリングに`?`演算子を活用
?演算子を使うと、エラー処理を簡潔に記述できます。
use std::fs::File;
use std::io::{self, Read};
fn read_file_contents() -> io::Result<String> {
let mut file = File::open("data.txt")?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
fn main() {
match read_file_contents() {
Ok(data) => println!("ファイル内容: {}", data),
Err(e) => println!("エラー: {}", e),
}
}まとめ
バイナリファイル操作におけるエラーハンドリングのポイント：
- 適切なエラー処理：
Result型と?演算子でエラーを簡潔に処理する。 - エラーの分類：
ErrorKindを使い、エラーの種類に応じた対処を行う。 - 事前確認：ファイルの存在や権限を事前に確認することで、予期しないエラーを防ぐ。
次項では、ファイル読み書きのパフォーマンス最適化について解説します。
ファイル読み書きのパフォーマンス最適化
Rustでバイナリファイルの読み書きを効率的に行うためには、いくつかのパフォーマンス最適化テクニックを活用することが重要です。ファイル操作の頻度やデータサイズに応じた適切な手法を選びましょう。
1. バッファリングの活用
ファイル操作を高速化する最も効果的な方法の一つは、バッファリングです。BufReaderやBufWriterを使うと、データの読み書きを効率化できます。
バッファ付き読み込みの例：
use std::fs::File;
use std::io::{self, BufReader, Read};
fn main() -> io::Result<()> {
let file = File::open("large_file.bin")?;
let mut reader = BufReader::new(file);
let mut buffer = Vec::new();
reader.read_to_end(&mut buffer)?;
println!("読み込んだデータの長さ: {}", buffer.len());
Ok(())
}バッファ付き書き込みの例：
use std::fs::File;
use std::io::{self, BufWriter, Write};
fn main() -> io::Result<()> {
let file = File::create("output.bin")?;
let mut writer = BufWriter::new(file);
let data = vec![0u8; 1024 * 1024]; // 1MBのデータ
writer.write_all(&data)?;
println!("データを書き込みました。");
Ok(())
}2. ストリームによる大容量データ処理
大きなファイルを一度にメモリに読み込むとメモリ不足になる可能性があります。ストリームを使ってデータを少しずつ処理しましょう。
use std::fs::File;
use std::io::{self, Read};
fn main() -> io::Result<()> {
let mut file = File::open("large_file.bin")?;
let mut buffer = [0u8; 1024]; // 1KBのバッファ
while let Ok(bytes_read) = file.read(&mut buffer) {
if bytes_read == 0 {
break;
}
println!("読み込んだバイト数: {}", bytes_read);
}
Ok(())
}3. ファイル書き込み時のフラッシュ操作の削減
ファイルにデータを書き込むたびにflush()を呼び出すとパフォーマンスが低下します。BufWriterは内部で自動的にバッファを管理するため、頻繁にflush()する必要はありません。
use std::fs::File;
use std::io::{self, BufWriter, Write};
fn main() -> io::Result<()> {
let file = File::create("output.bin")?;
let mut writer = BufWriter::new(file);
for _ in 0..1000 {
writer.write_all(b"Hello, Rust!")?;
}
// 最後に一度だけフラッシュ
writer.flush()?;
println!("書き込み完了");
Ok(())
}4. メモリマップ（Memory-Mapped I/O）の活用
大量のデータを扱う場合、メモリマップ（memmap2クレート）を使うことで、ファイルを効率的にメモリにマッピングできます。
memmap2クレートを使った例：
Cargo.tomlに以下を追加：
[dependencies]
memmap2 = "0.7"コード例：
use memmap2::Mmap;
use std::fs::File;
fn main() -> std::io::Result<()> {
let file = File::open("large_file.bin")?;
let mmap = unsafe { Mmap::map(&file)? };
println!("最初の10バイト: {:?}", &mmap[0..10]);
Ok(())
}5. 並列処理で効率化
データの読み書きを並列で処理することで、さらにパフォーマンスを向上させることができます。rayonクレートを活用すると手軽に並列処理が可能です。
Cargo.tomlに追加：
[dependencies]
rayon = "1.5"並列書き込みの例：
use rayon::prelude::*;
use std::fs::File;
use std::io::{self, Write};
fn main() -> io::Result<()> {
let file = File::create("output_parallel.bin")?;
let mut writer = io::BufWriter::new(file);
let data: Vec<u8> = (0..1_000_000).map(|x| (x % 256) as u8).collect();
data.par_chunks(1024).for_each(|chunk| {
writer.write_all(chunk).unwrap();
});
writer.flush()?;
println!("並列書き込み完了");
Ok(())
}まとめ
Rustでバイナリファイルの読み書きを効率化するためのテクニックを紹介しました：
- バッファリングの活用：
BufReaderやBufWriterで効率的なI/Oを実現。 - ストリーム処理：大容量ファイルを少しずつ読み書き。
- メモリマップI/O：巨大ファイルを効率的に操作。
- 並列処理：
rayonを活用して高速書き込み。
これらのテクニックを適切に組み合わせることで、効率的なファイル操作が可能になります。次項では、バッファリングやストリーム処理の詳細について解説します。
バッファリングとストリーム処理
バイナリファイルの読み書きを効率的に行うためには、バッファリングやストリーム処理の概念を理解し、適切に活用することが重要です。これらの手法を使うことで、大容量ファイルでもメモリ効率よく処理できます。
バッファリングとは
バッファリングは、ファイルのデータを一度にまとめて読み書きすることで、I/O操作の回数を減らし、パフォーマンスを向上させる手法です。Rustでは、BufReaderとBufWriterが標準ライブラリで提供されています。
バッファ付き読み込みの例
BufReaderを使用してファイルを効率よく読み込みます。
use std::fs::File;
use std::io::{self, BufReader, Read};
fn main() -> io::Result<()> {
let file = File::open("large_file.bin")?;
let mut reader = BufReader::new(file);
let mut buffer = Vec::new();
// バッファ経由でファイルを読み込む
reader.read_to_end(&mut buffer)?;
println!("読み込んだデータの長さ: {}", buffer.len());
Ok(())
}解説：
BufReaderがファイル読み込み時に内部バッファを利用し、複数回のI/O操作をまとめます。- バッファのデフォルトサイズは8KBですが、
BufReader::with_capacityを使えばサイズを変更できます。
バッファ付き書き込みの例
BufWriterを使って効率的にデータを書き込みます。
use std::fs::File;
use std::io::{self, BufWriter, Write};
fn main() -> io::Result<()> {
let file = File::create("output.bin")?;
let mut writer = BufWriter::new(file);
for i in 0..1000 {
writer.write_all(&[i as u8])?;
}
// 最後にバッファをフラッシュ
writer.flush()?;
println!("書き込み完了");
Ok(())
}解説：
BufWriterがデータを書き込む際にバッファリングし、I/O操作を減らします。flush()でバッファ内のデータをファイルに確定させます。
ストリーム処理とは
ストリーム処理は、ファイルを一度にすべて読み込まず、データを小さなチャンク（塊）に分けて少しずつ処理する方法です。大容量ファイルを扱う場合に効果的です。
読み取りストリーム処理の例
use std::fs::File;
use std::io::{self, Read};
fn main() -> io::Result<()> {
let mut file = File::open("large_file.bin")?;
let mut buffer = [0u8; 1024]; // 1KBのバッファ
while let Ok(bytes_read) = file.read(&mut buffer) {
if bytes_read == 0 {
break;
}
println!("読み込んだバイト数: {}", bytes_read);
}
Ok(())
}解説：
- 1KBずつファイルを読み込むことで、メモリ使用量を抑えます。
- 読み込むデータがなくなるまでループが続きます。
書き込みストリーム処理の例
use std::fs::File;
use std::io::{self, Write};
fn main() -> io::Result<()> {
let mut file = File::create("output_stream.bin")?;
for i in 0..10000 {
file.write_all(&[i as u8])?;
}
println!("ストリーム書き込み完了");
Ok(())
}解説：
- データを少しずつ書き込み、大容量データを効率的に処理します。
バッファリングとストリーム処理の選び方
| シチュエーション | 推奨手法 |
|---|---|
| 小さいファイルを一度に読み書きする場合 | fs::read / fs::write |
| 大きなファイルを効率的に読み書きする場合 | BufReader / BufWriter |
| 非同期にデータを少しずつ処理する場合 | ストリーム処理 |
| 大容量ファイルをメモリ効率よく操作する場合 | メモリマップ |
まとめ
バイナリファイルの効率的な読み書きには、バッファリングとストリーム処理が欠かせません。
- バッファリングはI/O操作をまとめてパフォーマンスを向上させます。
- ストリーム処理は大容量ファイルを少しずつ処理し、メモリの使用量を抑えます。
次項では、これらの技術を応用した実例について解説します。
応用例：設定ファイルやデータベースの読み書き
Rustでバイナリファイルの読み書きを習得すると、さまざまな実用的なシナリオに応用できます。ここでは、設定ファイルの保存やシンプルなバイナリ形式のデータベースを扱う例を紹介します。
1. バイナリ形式の設定ファイルの読み書き
設定データをバイナリファイルに保存し、読み込む例です。serdeとbincodeクレートを使ってシリアライズ・デシリアライズを行います。
Cargo.tomlに依存関係を追加
[dependencies]
serde = { version = "1.0", features = ["derive"] }
bincode = "1.3"設定データの読み書きコード
use serde::{Deserialize, Serialize};
use std::fs::File;
use std::io::{self, Read, Write};
#[derive(Serialize, Deserialize, Debug)]
struct Config {
username: String,
volume: u8,
fullscreen: bool,
}
fn save_config(config: &Config, path: &str) -> io::Result<()> {
let encoded = bincode::serialize(config).unwrap();
let mut file = File::create(path)?;
file.write_all(&encoded)?;
Ok(())
}
fn load_config(path: &str) -> io::Result<Config> {
let mut file = File::open(path)?;
let mut buffer = Vec::new();
file.read_to_end(&mut buffer)?;
let config: Config = bincode::deserialize(&buffer).unwrap();
Ok(config)
}
fn main() -> io::Result<()> {
let config = Config {
username: "Alice".to_string(),
volume: 75,
fullscreen: true,
};
let path = "config.bin";
// 設定を保存
save_config(&config, path)?;
println!("設定を保存しました: {:?}", config);
// 設定を読み込み
let loaded_config = load_config(path)?;
println!("設定を読み込みました: {:?}", loaded_config);
Ok(())
}解説：
Config構造体：設定データを表す構造体で、SerializeとDeserializeトレイトを実装しています。bincode::serialize：構造体をバイナリ形式にシリアライズします。bincode::deserialize：バイナリデータを構造体にデシリアライズします。
2. シンプルなバイナリデータベース
シンプルなキーと値のペアをバイナリ形式で保存するデータベースを作成します。
データベースの読み書きコード
use std::collections::HashMap;
use std::fs::File;
use std::io::{self, Read, Write};
fn save_database(db: &HashMap<String, String>, path: &str) -> io::Result<()> {
let mut file = File::create(path)?;
for (key, value) in db {
let entry = format!("{}\n{}\n", key, value);
file.write_all(entry.as_bytes())?;
}
Ok(())
}
fn load_database(path: &str) -> io::Result<HashMap<String, String>> {
let mut file = File::open(path)?;
let mut content = String::new();
file.read_to_string(&mut content)?;
let mut db = HashMap::new();
let mut lines = content.lines();
while let Some(key) = lines.next() {
if let Some(value) = lines.next() {
db.insert(key.to_string(), value.to_string());
}
}
Ok(db)
}
fn main() -> io::Result<()> {
let mut db = HashMap::new();
db.insert("name".to_string(), "Alice".to_string());
db.insert("city".to_string(), "Tokyo".to_string());
let path = "database.bin";
// データベースを保存
save_database(&db, path)?;
println!("データベースを保存しました: {:?}", db);
// データベースを読み込み
let loaded_db = load_database(path)?;
println!("データベースを読み込みました: {:?}", loaded_db);
Ok(())
}解説：
- キーと値のペアをテキスト形式で保存するシンプルなデータベースです。
- ファイルには各エントリが改行区切りで保存されます。
HashMapを使用してデータを管理し、保存・読み込みを行います。
3. バイナリログファイルの作成
アプリケーションの動作ログをバイナリ形式で保存する例です。
use std::fs::File;
use std::io::{self, Write};
fn log_event(file: &mut File, event: &str) -> io::Result<()> {
let timestamp = chrono::Local::now();
let log_entry = format!("{}: {}\n", timestamp, event);
file.write_all(log_entry.as_bytes())?;
Ok(())
}
fn main() -> io::Result<()> {
let mut file = File::create("app_log.bin")?;
log_event(&mut file, "アプリケーション起動")?;
log_event(&mut file, "ユーザーログイン")?;
log_event(&mut file, "データ処理完了")?;
println!("ログが記録されました。");
Ok(())
}解説：
log_event関数：現在のタイムスタンプとイベント内容をログファイルに書き込みます。chronoクレートを使用してタイムスタンプを取得します。
まとめ
バイナリファイルの読み書きは、さまざまな実用シナリオに応用できます：
- 設定ファイルの保存と読み込み：アプリケーション設定をバイナリ形式で管理。
- シンプルなデータベース：キーと値のペアを効率的に保存。
- ログファイルの作成：アプリケーションの動作記録をバイナリ形式で保存。
これらの技術を活用することで、Rustアプリケーションのデータ管理が効率化されます。次項では、記事全体の内容をまとめます。
まとめ
本記事では、Rustを使ったバイナリファイルの読み書きについて解説しました。std::fs::readやstd::fs::writeを用いた基本的な操作から、バッファリング、ストリーム処理、エラーハンドリング、そして応用例として設定ファイルやシンプルなデータベースの操作方法を紹介しました。
効率的なファイル操作には、バッファリングやストリーム処理の活用が欠かせません。適切なエラーハンドリングを行うことで、予期しない問題にも柔軟に対応でき、堅牢なアプリケーション開発が可能になります。
Rustの強力な型システムと安全性を活かして、効率的で信頼性の高いバイナリファイル操作をマスターしましょう。これにより、データ処理やファイル管理のスキルが一段と向上し、さまざまなプロジェクトに応用できる知識が身につきます。
コメント