MENU
  1. ホーム
  2. Rust
  3. Rustでモジュールのネストを使いドメインごとにコードを整理する方法

Rustでモジュールのネストを使いドメインごとにコードを整理する方法

Rust

Rustでプログラムを書く際、コードが複雑になるにつれて、整理整頓が重要になります。特に、大規模なプロジェクトや複数のドメイン（機能領域）を扱う場合、コードの構造が一貫していないと、保守や拡張が難しくなります。Rustには、強力なモジュールシステムがあり、コードをネストしてドメインごとに整理することで、可読性や再利用性を高めることができます。本記事では、Rustのモジュールシステムを活用して、コードを効率よく分割・整理する方法について詳しく解説します。

目次
  1. モジュールシステムの基本構造
    1. モジュールとは
    2. 基本的なモジュールの宣言
    3. ファイルとディレクトリを使ったモジュール
    4. モジュールの利点
  2. モジュールのネストの仕組み
    1. 基本的なモジュールのネスト方法
    2. 複数ファイルを使ったネスト
    3. モジュールのパスと可視性
    4. ネストを活用する利点
  3. ドメインごとにコードを分割する方法
    1. ドメインごとの分割とは？
    2. モジュール構成の例
    3. main.rs
    4. auth/mod.rs
    5. auth/login.rs
    6. db/mod.rs
    7. db/connection.rs
    8. handlers/mod.rs
    9. handlers/user_handler.rs
    10. ドメインごとに分割する利点
    11. ベストプラクティス
  4. モジュールの宣言と参照方法
    1. モジュールの宣言
    2. モジュールの参照方法
    3. `use`キーワードでの参照
    4. サブモジュールの宣言と参照
    5. 複数ファイルを使ったモジュール宣言
    6. モジュール参照のまとめ
  5. モジュールファイル構成の例
    1. シンプルなプロジェクト構成
    2. 各ファイルの内容
    3. 複数階層のモジュール構成
    4. 各ファイルの内容
    5. ファイル構成の解説
    6. もっと大規模なプロジェクト構成例
    7. モジュール分割のベストプラクティス
  6. パブリックとプライベートの管理
    1. デフォルトはプライベート
    2. 構造体とフィールドの可視性
    3. モジュールの可視性管理
    4. サブモジュールのプライベート管理
    5. ベストプラクティス
  7. ベストプラクティスと注意点
    1. 1. モジュールはシンプルに保つ
    2. 2. ファイル構成をドメインごとに整理する
    3. 3. モジュール内の要素の可視性を適切に管理
    4. 4. `use`でパスを簡略化する
    5. 5. エラー処理を適切に行う
    6. 6. モジュール間の依存関係を最小限にする
    7. 7. テストを各モジュールに配置する
    8. まとめ
  8. 演習問題：モジュールを使ったサンプルプロジェクト
    1. プロジェクト概要
    2. ファイル構成
    3. ステップ1：`Cargo.toml`の作成
    4. ステップ2：`src/main.rs`の作成
    5. ステップ3：`src/auth/mod.rs`の作成
    6. ステップ4：`src/auth/login.rs`の作成
    7. ステップ5：`src/messages.rs`の作成
    8. 実行結果
    9. 演習問題
    10. 解答例：`logout`機能の追加
  9. まとめ

モジュールシステムの基本構造

Rustのモジュールシステムは、コードを論理的に分割し、整理するための仕組みです。これにより、関連する機能をグループ化し、プロジェクトの可読性や保守性を向上させることができます。

モジュールとは

モジュール（mod）は、Rustにおけるコードの分割単位です。モジュールを使うことで、1つのファイルや関数に依存せず、複数のファイルやディレクトリにコードを整理できます。モジュールは、関連する関数、構造体、定数などをグループ化します。

基本的なモジュールの宣言

モジュールを宣言するには、modキーワードを使用します。

mod my_module {
    pub fn say_hello() {
        println!("Hello from my_module!");
    }
}

fn main() {
    my_module::say_hello();
}

この例では、my_moduleというモジュールを定義し、その中にsay_hello関数を作成しています。関数を呼び出すには、my_module::say_hello()のようにパスで指定します。

ファイルとディレクトリを使ったモジュール

モジュールは別のファイルとして定義することも可能です。例えば、my_module.rsというファイルを作成し、その中にモジュールのコードを書くことができます。

ディレクトリ構造の例：

src/
├── main.rs
└── my_module.rs

main.rs内で次のように記述します：

mod my_module; // my_module.rsファイルをインクルード

fn main() {
    my_module::say_hello();
}

これにより、my_module.rsにあるコードがmain.rsで利用できるようになります。

モジュールの利点

  • コードの整理：関連する機能をまとめて管理できます。
  • 再利用性の向上：モジュール単位で機能を分割することで、再利用しやすくなります。
  • 名前空間の管理：モジュールが名前空間を提供するため、名前の衝突を避けられます。

Rustのモジュールシステムを理解することで、プロジェクトをスムーズに拡張・保守できるようになります。

モジュールのネストの仕組み

Rustでは、モジュールを階層的にネストすることで、より細かくコードを整理し、ドメインごとにグループ化することができます。これにより、プロジェクトの複雑性が増しても管理が容易になります。

基本的なモジュールのネスト方法

モジュール内にさらにモジュールを作ることができます。次の例は、ネストされたモジュールの基本的な構造です。

mod outer {
    pub mod inner {
        pub fn say_hello() {
            println!("Hello from inner module!");
        }
    }
}

fn main() {
    outer::inner::say_hello();
}

この例では、outerモジュールの中にinnerモジュールがネストされており、outer::inner::say_hello()で関数にアクセスしています。

複数ファイルを使ったネスト

複数のファイルを使ってネストする場合、ディレクトリ構造を以下のように整理できます。

src/
├── main.rs
└── outer/
    ├── mod.rs
    └── inner.rs

ファイル内容：

  • main.rs
  mod outer;

  fn main() {
      outer::inner::say_hello();
  }
  • outer/mod.rs
  pub mod inner;
  • outer/inner.rs
  pub fn say_hello() {
      println!("Hello from nested module in multiple files!");
  }

この構成により、outerモジュール内にinnerモジュールがネストされ、outer::inner::say_hello()として呼び出せます。

モジュールのパスと可視性

ネストされたモジュールの関数や構造体にアクセスするためには、正しいパス指定が必要です。また、アイテムを外部から利用可能にするには、pubキーワードを使って可視性を公開する必要があります。

mod outer {
    pub mod inner {
        pub fn public_function() {
            println!("This is a public function.");
        }

        fn private_function() {
            println!("This is a private function.");
        }
    }
}

fn main() {
    outer::inner::public_function();
    // outer::inner::private_function(); // エラー：private function
}

ネストを活用する利点

  • 論理的な整理：階層構造により、関連するコードをまとめやすくなります。
  • スコープ管理：モジュールが名前空間を提供し、名前の衝突を防ぎます。
  • 保守性向上：大規模プロジェクトでもコードの見通しが良くなります。

Rustのモジュールのネストを効果的に使うことで、プロジェクトの拡張や保守が容易になります。

ドメインごとにコードを分割する方法

大規模なRustプロジェクトでは、複数の機能や関心ごと（ドメイン）を効率よく管理するために、モジュールを使ってコードを整理するのが効果的です。ドメインごとに分割することで、コードの可読性や保守性が向上し、開発効率も高まります。

ドメインごとの分割とは？

ドメインごとの分割とは、特定の機能や処理に関するコードを1つのモジュールにまとめることです。例えば、Webアプリケーションでは以下のようなドメインで分割できます：

  • 認証処理（authentication）
  • データベース操作（database）
  • APIハンドラ（handlers）
  • ユーティリティ関数（utils）

モジュール構成の例

以下は、Webアプリケーションを想定したモジュール構成の例です。

src/
├── main.rs
├── auth/
│   ├── mod.rs
│   └── login.rs
├── db/
│   ├── mod.rs
│   └── connection.rs
└── handlers/
    ├── mod.rs
    └── user_handler.rs

main.rs

mod auth;
mod db;
mod handlers;

fn main() {
    println!("Starting the application...");
    auth::login::login_user();
    db::connection::connect();
    handlers::user_handler::handle_user_request();
}

auth/mod.rs

pub mod login;

auth/login.rs

pub fn login_user() {
    println!("User logged in.");
}

db/mod.rs

pub mod connection;

db/connection.rs

pub fn connect() {
    println!("Database connected.");
}

handlers/mod.rs

pub mod user_handler;

handlers/user_handler.rs

pub fn handle_user_request() {
    println!("Handling user request.");
}

ドメインごとに分割する利点

  1. 可読性向上
    コードが整理され、目的ごとにファイルが分かれているため、どこに何があるかがすぐに分かります。
  2. 保守性と拡張性
    新しい機能の追加や修正が容易になり、影響範囲を限定できます。
  3. テストの容易さ
    ドメインごとにテストを書きやすく、特定の機能だけをテストすることができます。
  4. 協業がしやすい
    チームで開発する際に、ドメインごとに担当を分けやすくなります。

ベストプラクティス

  • 関連する機能は1つのモジュールにまとめる
    例えば、認証関連の関数はすべてauthモジュールにまとめます。
  • モジュール名は明確でわかりやすく
    ドメイン名が一目で理解できるように名前を付けます。
  • 適切な可視性管理
    外部から必要な関数だけをpubで公開し、内部でのみ使用する関数は非公開にします。

ドメインごとにモジュールを分割することで、Rustプロジェクトを効率的に整理し、管理しやすい構造にすることができます。

モジュールの宣言と参照方法

Rustでモジュールを効果的に使うためには、モジュールの宣言と参照の仕組みを理解することが重要です。ここでは、modを使ったモジュールの宣言方法や、useを用いた参照方法について解説します。

モジュールの宣言

モジュールを宣言するには、modキーワードを使用します。以下は、基本的なモジュール宣言の例です。

mod greetings {
    pub fn say_hello() {
        println!("Hello from the greetings module!");
    }
}
  • mod greetings：greetingsというモジュールを宣言しています。
  • pub fn say_hello()：pubキーワードを使って、関数をモジュールの外部から呼び出せるようにしています。

モジュールの参照方法

宣言したモジュールの関数やアイテムにアクセスするには、次のようにパスを使います。

fn main() {
    greetings::say_hello();
}

ここでのgreetings::say_hello()は、greetingsモジュール内のsay_hello関数を呼び出しています。

`use`キーワードでの参照

パスが長くなるのを避けるため、useキーワードを使ってモジュールのアイテムを参照できます。

mod greetings {
    pub fn say_hello() {
        println!("Hello from the greetings module!");
    }
}

use greetings::say_hello;

fn main() {
    say_hello();
}
  • use greetings::say_hello;：say_hello関数をgreetingsモジュールからインポートしています。
  • これにより、say_hello()と短い名前で関数を呼び出せます。

サブモジュールの宣言と参照

モジュールの中にサブモジュールを作ることもできます。

mod parent {
    pub mod child {
        pub fn say_hello() {
            println!("Hello from the child module!");
        }
    }
}

fn main() {
    parent::child::say_hello();
}
  • pub mod child：parentモジュール内にchildというサブモジュールを宣言しています。
  • parent::child::say_hello()：サブモジュール内の関数を呼び出しています。

複数ファイルを使ったモジュール宣言

モジュールはファイルとして分割することもできます。例えば、次のようなディレクトリ構造を考えます。

src/
├── main.rs
└── greetings.rs
  • main.rs:
  mod greetings;

  fn main() {
      greetings::say_hello();
  }
  • greetings.rs:
  pub fn say_hello() {
      println!("Hello from greetings.rs!");
  }

この構成により、greetings.rsに書かれたモジュールをmain.rsから利用できます。

モジュール参照のまとめ

  • modで宣言：モジュールを宣言する。
  • パスで参照：module::function()の形式で参照する。
  • useで簡略化：長いパスを省略して参照する。
  • ファイル分割：モジュールをファイルに分割し、大規模なプロジェクトを整理する。

これらの方法を使いこなすことで、Rustプロジェクトのコードを効率よく整理し、管理しやすくすることができます。

モジュールファイル構成の例

Rustのプロジェクトが大きくなると、モジュールをファイルやディレクトリに分割して整理することが不可欠です。ここでは、具体的なファイル構成例を示し、どのようにモジュールを分割・管理するかを解説します。

シンプルなプロジェクト構成

基本的なモジュールの分割を行った場合の構成は次の通りです。

my_project/
├── Cargo.toml
└── src/
    ├── main.rs
    ├── auth.rs
    └── utils.rs

各ファイルの内容

  • main.rs
  mod auth;
  mod utils;

  fn main() {
      auth::login();
      utils::say_hello();
  }
  • auth.rs
  pub fn login() {
      println!("User logged in!");
  }
  • utils.rs
  pub fn say_hello() {
      println!("Hello from utils!");
  }

このように、main.rsから各モジュールファイルをmodで宣言し、それぞれのモジュール内で関数を定義しています。

複数階層のモジュール構成

複数のドメインや複雑な機能がある場合、ディレクトリを使ってモジュールを階層的に整理します。

my_project/
├── Cargo.toml
└── src/
    ├── main.rs
    └── auth/
        ├── mod.rs
        └── login.rs

各ファイルの内容

  • main.rs
  mod auth;

  fn main() {
      auth::login::authenticate();
  }
  • auth/mod.rs
  pub mod login;
  • auth/login.rs
  pub fn authenticate() {
      println!("User authenticated!");
  }

ファイル構成の解説

  1. main.rs
    エントリーポイントであり、他のモジュールを宣言し、それらの関数を呼び出します。
  2. モジュール用のディレクトリとmod.rs
  • auth/mod.rsは、authディレクトリ内のモジュールをまとめる役割を持ちます。
  • さらに細かく分けたモジュール（login.rs）を公開しています。
  1. サブモジュールファイル
    auth/login.rsでは、認証関連の処理を定義しています。

もっと大規模なプロジェクト構成例

my_project/
├── Cargo.toml
└── src/
    ├── main.rs
    ├── auth/
    │   ├── mod.rs
    │   └── login.rs
    ├── db/
    │   ├── mod.rs
    │   └── connection.rs
    └── handlers/
        ├── mod.rs
        └── user_handler.rs

このように、大規模なプロジェクトではドメインごとにディレクトリを作り、その中でさらにファイルを分割することで管理しやすくなります。

モジュール分割のベストプラクティス

  1. ドメインごとにディレクトリを作成
    認証、データベース、ハンドラなど、機能ごとにディレクトリを分けます。
  2. mod.rsの活用
    ディレクトリ内の複数のファイルをまとめるためにmod.rsを利用します。
  3. 適切な可視性管理
    外部から利用する関数にはpubを付け、内部処理は非公開にします。

Rustのモジュールシステムを効果的に活用することで、プロジェクトの拡張や保守がしやすい構成を実現できます。

パブリックとプライベートの管理

Rustでは、モジュール内の要素（関数、構造体、定数など）に対して、パブリック（公開）またはプライベート（非公開）といった可視性を設定できます。適切にパブリックとプライベートを管理することで、外部からアクセスできる範囲を制限し、カプセル化を実現できます。

デフォルトはプライベート

Rustでは、モジュール内の要素はデフォルトでプライベートです。そのため、モジュールの外部からアクセスするには、pubキーワードで公開する必要があります。

例：デフォルトのプライベート要素

mod my_module {
    fn private_function() {
        println!("This is a private function.");
    }

    pub fn public_function() {
        println!("This is a public function.");
    }
}

fn main() {
    my_module::public_function();
    // my_module::private_function(); // コンパイルエラー：プライベート関数
}
  • private_functionはモジュール内のみで呼び出せます。
  • public_functionはpubで公開されているため、モジュール外から呼び出せます。

構造体とフィールドの可視性

構造体自体を公開しても、そのフィールドはデフォルトでプライベートです。フィールドを公開するには、それぞれにpubを付けます。

mod my_module {
    pub struct PublicStruct {
        pub public_field: i32,
        private_field: i32,
    }

    impl PublicStruct {
        pub fn new(value: i32) -> Self {
            PublicStruct {
                public_field: value,
                private_field: value * 2,
            }
        }
    }
}

fn main() {
    let instance = my_module::PublicStruct::new(10);
    println!("Public field: {}", instance.public_field);
    // println!("Private field: {}", instance.private_field); // コンパイルエラー：プライベートフィールド
}
  • 構造体自体は公開されているため、PublicStructはモジュール外から使用できます。
  • public_fieldは公開されているため、外部からアクセス可能です。
  • private_fieldはプライベートのため、モジュール外からアクセスできません。

モジュールの可視性管理

モジュール自体もpubを使って公開できます。

pub mod outer {
    pub mod inner {
        pub fn say_hello() {
            println!("Hello from inner module!");
        }
    }
}

fn main() {
    outer::inner::say_hello();
}
  • pub mod outerとpub mod innerで、外部からアクセスできるモジュールとして公開しています。

サブモジュールのプライベート管理

モジュールをプライベートにすることで、内部モジュールへのアクセスを制限できます。

mod outer {
    mod inner {
        pub fn private_hello() {
            println!("Hello from a private inner module!");
        }
    }
}

fn main() {
    // outer::inner::private_hello(); // コンパイルエラー：プライベートモジュール
}

ベストプラクティス

  1. 必要な要素のみ公開
    外部からアクセスが必要な関数やフィールドだけにpubを付け、不要なものはプライベートにします。
  2. カプセル化の維持
    内部ロジックやデータをプライベートにすることで、モジュールの一貫性を保ちます。
  3. モジュールのインターフェース設計
    公開する関数や構造体を適切に設計し、モジュールが提供する機能を明確にします。

Rustのパブリックとプライベートの管理を理解し適切に使用することで、安全で保守性の高いコードが書けるようになります。

ベストプラクティスと注意点

Rustでモジュールのネストやドメインごとのコード分割を行う際には、効率的なプロジェクト管理のためにいくつかのベストプラクティスと注意点を理解しておくことが重要です。ここでは、モジュールを適切に管理し、保守性と可読性を高めるためのポイントを解説します。

1. モジュールはシンプルに保つ

モジュールは1つの目的に絞り、シンプルに保つことが重要です。1つのモジュールに多くの責務を詰め込むと、コードが複雑になり、保守が困難になります。

例：悪いモジュール設計

mod app {
    pub fn login() {
        println!("Logging in...");
    }

    pub fn logout() {
        println!("Logging out...");
    }

    pub fn connect_db() {
        println!("Connecting to database...");
    }
}

改善例：モジュールを分割する

mod auth {
    pub fn login() {
        println!("Logging in...");
    }

    pub fn logout() {
        println!("Logging out...");
    }
}

mod db {
    pub fn connect() {
        println!("Connecting to database...");
    }
}

2. ファイル構成をドメインごとに整理する

大規模なプロジェクトでは、ファイルとディレクトリをドメインごとに整理することで、コードの見通しが良くなります。

ディレクトリ構成例：

src/
├── main.rs
├── auth/
│   ├── mod.rs
│   └── login.rs
└── db/
    ├── mod.rs
    └── connection.rs

3. モジュール内の要素の可視性を適切に管理

  • 公開すべき要素にはpubを付ける：外部からアクセスが必要な関数や構造体はpubで公開します。
  • 内部ロジックは非公開にする：モジュール内でのみ使用する関数やデータは非公開にして、カプセル化を維持します。

例：適切な可視性の管理

mod auth {
    pub fn login() {
        println!("User logged in.");
    }

    fn validate_credentials() {
        println!("Validating credentials...");
    }
}

4. `use`でパスを簡略化する

長いパスの呼び出しを避けるために、useを活用してコードを簡潔に保ちましょう。

例：useを使った簡略化

mod auth {
    pub mod login {
        pub fn authenticate() {
            println!("Authenticating user...");
        }
    }
}

use auth::login::authenticate;

fn main() {
    authenticate();
}

5. エラー処理を適切に行う

モジュールごとにエラー処理を適切に実装し、問題が発生した際に分かりやすいエラーを返すようにしましょう。

例：エラー処理の実装

mod auth {
    pub fn login(username: &str) -> Result<(), String> {
        if username.is_empty() {
            return Err("Username cannot be empty".to_string());
        }
        println!("User logged in successfully.");
        Ok(())
    }
}

fn main() {
    match auth::login("") {
        Ok(_) => println!("Login successful"),
        Err(e) => println!("Error: {}", e),
    }
}

6. モジュール間の依存関係を最小限にする

モジュール同士が密に依存すると、変更が影響しやすくなります。可能な限り、依存関係を少なくし、モジュールを独立させましょう。

7. テストを各モジュールに配置する

Rustでは、モジュールごとにテストを書くことが推奨されます。

例：モジュール内にテストを配置

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}

まとめ

  • モジュールはシンプルに保つ
  • ファイルとディレクトリをドメインごとに整理する
  • 可視性を適切に管理する
  • useでパスを簡略化する
  • エラー処理とテストを各モジュールに実装する

これらのベストプラクティスを守ることで、Rustプロジェクトを効率的に管理し、拡張や保守がしやすいコードを構築できます。

演習問題：モジュールを使ったサンプルプロジェクト

ここでは、Rustのモジュールシステムを活用し、簡単なサンプルプロジェクトを作成することで、モジュールの使い方やコード分割の方法を実践的に学びます。

プロジェクト概要

簡易認証システムを作成します。このシステムでは、ユーザーがログインできる機能を提供し、認証に成功したらウェルカムメッセージを表示します。

ファイル構成

次のようなディレクトリ構造でプロジェクトを作成します。

auth_system/
├── Cargo.toml
└── src/
    ├── main.rs
    ├── auth/
    │   ├── mod.rs
    │   └── login.rs
    └── messages.rs

ステップ1：`Cargo.toml`の作成

[package]
name = "auth_system"
version = "0.1.0"
edition = "2021"

ステップ2：`src/main.rs`の作成

mod auth;
mod messages;

fn main() {
    let username = "Alice";
    let password = "password123";

    match auth::login::authenticate(username, password) {
        Ok(_) => messages::welcome_message(username),
        Err(e) => println!("Error: {}", e),
    }
}

ステップ3：`src/auth/mod.rs`の作成

pub mod login;

ステップ4：`src/auth/login.rs`の作成

pub fn authenticate(username: &str, password: &str) -> Result<(), String> {
    if username == "Alice" && password == "password123" {
        Ok(())
    } else {
        Err("Invalid username or password".to_string())
    }
}

ステップ5：`src/messages.rs`の作成

pub fn welcome_message(username: &str) {
    println!("Welcome, {}! You have successfully logged in.", username);
}

実行結果

ターミナルで次のコマンドを実行して、プログラムをビルドして実行します。

cargo run

出力結果:

Welcome, Alice! You have successfully logged in.

演習問題

  1. エラー処理の追加
  • ユーザー名やパスワードが空の場合にエラーを返すようにauthenticate関数を修正してください。
  1. 新しいモジュールの追加
  • logout機能をauth/logout.rsに追加し、ユーザーがログアウトしたときにメッセージを表示する機能を作成してください。
  1. テストの追加
  • auth/login.rsにauthenticate関数のテストを書いて、正しい認証と誤った認証のテストを行ってください。

解答例：`logout`機能の追加

ファイル構成に新たなファイルを追加:

src/
└── auth/
    └── logout.rs

src/auth/mod.rs

pub mod login;
pub mod logout;

src/auth/logout.rs

pub fn logout(username: &str) {
    println!("Goodbye, {}! You have successfully logged out.", username);
}

src/main.rsにログアウト処理を追加:

mod auth;
mod messages;

fn main() {
    let username = "Alice";
    let password = "password123";

    match auth::login::authenticate(username, password) {
        Ok(_) => {
            messages::welcome_message(username);
            auth::logout::logout(username);
        }
        Err(e) => println!("Error: {}", e),
    }
}

実行結果:

Welcome, Alice! You have successfully logged in.
Goodbye, Alice! You have successfully logged out.

この演習を通じて、Rustのモジュールシステムを活用したコードの分割と管理方法を理解できたでしょう。これを基に、さらに複雑なプロジェクトに挑戦してみてください！

まとめ

本記事では、Rustにおけるモジュールのネストを利用してドメインごとにコードを分割・整理する方法について解説しました。モジュールシステムの基本構造から、具体的な宣言・参照方法、パブリックとプライベートの管理、そしてベストプラクティスまで、段階的に説明しました。

モジュールを適切に活用することで、次のような利点が得られます：

  • コードの可読性と保守性の向上
    ドメインごとにコードを整理し、管理しやすい構造にできます。
  • 名前空間の管理
    モジュールを使うことで名前の衝突を避け、明確なスコープを維持できます。
  • カプセル化の実現
    必要な部分だけを公開し、内部実装は隠蔽することで、安全で効率的なコードが書けます。

サンプルプロジェクトや演習問題を通じて、実践的にモジュールの分割と管理方法を学ぶことができました。これを基に、より大規模で複雑なRustプロジェクトにも対応できるスキルを磨いていきましょう。

Rust
モジュール プログラミング コード分割 Rust

コメント

コメントする

目次
  1. モジュールシステムの基本構造
    1. モジュールとは
    2. 基本的なモジュールの宣言
    3. ファイルとディレクトリを使ったモジュール
    4. モジュールの利点
  2. モジュールのネストの仕組み
    1. 基本的なモジュールのネスト方法
    2. 複数ファイルを使ったネスト
    3. モジュールのパスと可視性
    4. ネストを活用する利点
  3. ドメインごとにコードを分割する方法
    1. ドメインごとの分割とは？
    2. モジュール構成の例
    3. main.rs
    4. auth/mod.rs
    5. auth/login.rs
    6. db/mod.rs
    7. db/connection.rs
    8. handlers/mod.rs
    9. handlers/user_handler.rs
    10. ドメインごとに分割する利点
    11. ベストプラクティス
  4. モジュールの宣言と参照方法
    1. モジュールの宣言
    2. モジュールの参照方法
    3. `use`キーワードでの参照
    4. サブモジュールの宣言と参照
    5. 複数ファイルを使ったモジュール宣言
    6. モジュール参照のまとめ
  5. モジュールファイル構成の例
    1. シンプルなプロジェクト構成
    2. 各ファイルの内容
    3. 複数階層のモジュール構成
    4. 各ファイルの内容
    5. ファイル構成の解説
    6. もっと大規模なプロジェクト構成例
    7. モジュール分割のベストプラクティス
  6. パブリックとプライベートの管理
    1. デフォルトはプライベート
    2. 構造体とフィールドの可視性
    3. モジュールの可視性管理
    4. サブモジュールのプライベート管理
    5. ベストプラクティス
  7. ベストプラクティスと注意点
    1. 1. モジュールはシンプルに保つ
    2. 2. ファイル構成をドメインごとに整理する
    3. 3. モジュール内の要素の可視性を適切に管理
    4. 4. `use`でパスを簡略化する
    5. 5. エラー処理を適切に行う
    6. 6. モジュール間の依存関係を最小限にする
    7. 7. テストを各モジュールに配置する
    8. まとめ
  8. 演習問題：モジュールを使ったサンプルプロジェクト
    1. プロジェクト概要
    2. ファイル構成
    3. ステップ1：`Cargo.toml`の作成
    4. ステップ2：`src/main.rs`の作成
    5. ステップ3：`src/auth/mod.rs`の作成
    6. ステップ4：`src/auth/login.rs`の作成
    7. ステップ5：`src/messages.rs`の作成
    8. 実行結果
    9. 演習問題
    10. 解答例：`logout`機能の追加
  9. まとめ