大人数の開発でも迷わない!JavaScriptクラスがもたらす再利用性とコード共通化のメリット

大人数のJavaScript開発でクラスを活用しコードを再利用・共通化するイメージ プログラミング言語

JavaScriptで規模の大きな開発を進めていると、「この処理、別の場所でも使っているはずなのに、なぜか実装が少しずつ違う」という問題に直面することがあります。

特に、複数人が同じコードベースを扱う現場では、機能追加や仕様変更のたびに似たような処理が増え、やがて修正漏れや実装のばらつきにつながります。
個々のコードが正しく動いていても、全体として見れば保守しにくい状態になっていることも珍しくありません。

そこで重要になるのが、JavaScriptのクラスを活用した再利用性とコードの共通化です。
クラスは単にオブジェクトを作るための構文ではなく、関連するデータと処理をひとまとまりにして、同じ設計思想を複数の箇所で再利用しやすくするための仕組みとして活用できます。

では、クラスを導入すると、実際の開発現場で何が変わるのでしょうか。
共通処理を一箇所に集約することで、コードの重複を減らせるだけでなく、仕様変更時の修正範囲を限定しやすくなります。
さらに、役割や責務を明確に設計すれば、チーム内でコードの読み方や拡張方法を揃えることにもつながります。

本記事では、大人数でJavaScriptを開発するケースを想定しながら、クラスがもたらす再利用性の考え方と、コード共通化によるメリットを整理します。
単に「同じコードを書かなくて済む」という話にとどめず、保守性、変更容易性、可読性、そしてチーム開発における設計の統一という観点から、なぜクラスが有効なのかを論理的に掘り下げていきます。

  1. JavaScriptクラスが大人数の開発で重要になる理由
  2. JavaScriptクラスの基本とオブジェクト指向の考え方
    1. JavaScriptクラスにおけるデータとメソッドの関係
    2. コンストラクターとインスタンスをどう捉えるか
    3. オブジェクト指向はクラスを増やすことではない
  3. クラスによるコード共通化で重複を減らすメリット
    1. 重複コードが保守性を下げる理由
    2. クラスで共通処理を集約する効果
    3. コード共通化がチーム開発にもたらすメリット
    4. 共通化では「何でもクラスにする」必要はない
  4. JavaScriptクラスの再利用性を高める設計ポイント
    1. クラスの責務を小さく保つ
    2. 依存関係を減らして利用しやすくする
    3. publicなインターフェースをシンプルにする
    4. 継承よりもコンポジションを検討する
    5. 状態を持たせすぎないことも重要
    6. 命名とインターフェースをチームで統一する
  5. 大規模開発でクラスを使うと保守性が向上する理由
    1. 変更の影響範囲を限定しやすい
    2. 共通処理を集約して修正漏れを防ぐ
    3. 読み手がコードの構造を理解しやすくなる
    4. テストしやすい構造を作れる
    5. 開発者の入れ替わりに強くなる
    6. 保守性を高めるにはクラスの境界設計が重要
  6. JavaScriptクラスで仕様変更や機能追加に強いコードを作る
    1. 仕様変更の影響範囲を小さくする
    2. 共通ルールをクラスに集約して仕様の一貫性を保つ
    3. 機能追加では既存コードを壊さないことが重要
    4. インターフェースを安定させて内部実装を変更しやすくする
    5. テストを通して仕様変更の安全性を高める
    6. 機能追加を想定したクラス設計の考え方
  7. チーム開発でJavaScriptクラスの責務を明確にする方法
    1. クラスの目的を一文で説明できるようにする
    2. 変更理由を基準に責務を分ける
    3. 公開するメソッドを必要最小限にする
    4. クラス間の依存関係を意識する
    5. 命名規則で責務をコードに表現する
    6. コードレビューで責務の境界を確認する
    7. ドキュメントとテストで責務を補強する
  8. JavaScriptクラスの使いすぎに注意すべきケース
    1. 単純な処理までクラス化しない
    2. 状態を持たない処理は関数のほうが分かりやすい
    3. クラスを増やしすぎると依存関係が複雑になる
    4. 継承を重ねすぎる設計には注意する
    5. データ構造にまでクラスを使う必要はあるのか
    6. フレームワークやライブラリの設計方針も考慮する
    7. クラス化するか判断するための視点
  9. 関数とJavaScriptクラスを使い分ける判断基準
    1. 関数を選ぶべき場面
    2. クラスを選ぶべき場面
    3. 再利用したいのは処理か、それとも状態を持つモデルか
    4. 変更のされ方を基準に選ぶ
    5. チーム開発では一貫した判断基準を持つ
    6. 迷ったときは最小限の抽象化から始める
  10. 大人数のJavaScript開発で再利用性と共通化を実現するまとめ
    1. 再利用性を高める鍵は責務の明確化
    2. コード共通化は変更コストの削減につながる
    3. 大人数のチームでは設計ルールの共有が重要
    4. クラスを使いすぎないことも設計品質の一部
    5. JavaScriptクラスを活用するときに意識したいこと

JavaScriptクラスが大人数の開発で重要になる理由

複数人でJavaScriptコードを設計する開発チームのイメージ

JavaScriptで複数人が同じプロジェクトを開発していると、コードの量そのものよりも、「同じような処理が複数箇所に存在していること」が問題になりやすいです。
たとえば、ユーザー情報を取得する処理、入力値を検証する処理、APIレスポンスを整形する処理などが、それぞれの担当者によって少しずつ異なる形で実装されるケースがあります。
最初は問題なく動作していても、仕様変更が入った瞬間に、その差異が大きな負債として表面化します。

大人数の開発では、単に「動くコード」を書くだけでは十分ではありません。
重要なのは、誰が実装しても一定のルールに沿ったコードになり、変更するときにも影響範囲を予測しやすい状態を維持することです。
そこで役立つのが、関連するデータと処理をひとつの単位として整理できるJavaScriptクラスです。
クラスを適切に使えば、処理の共通化と責務の明確化を同時に進められます。

特に注目したいのが、コードの再利用性です。
再利用とは、単純に同じコードをコピーして別の場所で使い回すことではありません。
一度定義した設計や振る舞いを、必要な場所から同じルールで利用できる状態を指します。
コピー&ペーストによる実装では、元のコードを修正しても複製先には自動的に反映されません。
一方、クラスとして共通の処理をまとめておけば、利用側はその仕組みを呼び出すだけで済みます。

たとえば、複数の画面でユーザー情報を扱う場合、それぞれの画面が個別にデータ処理を実装すると、似たロジックが増えていきます。
クラスを使ってユーザーに関する責務を集約すれば、データの扱い方や処理手順を統一しやすくなります。
結果として、開発者ごとの実装差を小さくでき、レビューで確認すべきポイントも整理しやすくなります。
レビューする側から見ても、「この処理はクラス側に集約されている」という前提があれば、コード全体の構造を追いやすくなるでしょう。

もうひとつ重要なのが、変更コストの低減です。
大規模な開発では、機能追加よりも既存機能の変更や仕様調整に時間を使う場面が少なくありません。
共通処理が複数箇所へ分散していると、一つの仕様変更に対して何ファイルも確認する必要があります。
修正漏れが起きれば、ある画面では新仕様、別の画面では旧仕様という不整合も発生します。
クラスによって共通部分を一元化しておけば、変更対象を限定しやすくなり、テストすべき範囲についても考えやすくなります。

さらに、クラスはチーム内の共通言語として機能する点も見逃せません。
「この処理はこのクラスの責務です」と明確に定義されていれば、新しく参加した開発者でもコードベースの構造を理解しやすくなります。
これはオンボーディングの効率にも関係します。
大人数のプロジェクトほど、個々の開発者がすべてのコードを把握することは現実的ではありません。
だからこそ、どこに何を置くのかという設計上の境界が重要になります。

もちろん、クラスを導入すれば自動的にコード品質が上がるわけではありません。
責務を詰め込みすぎたり、継承を複雑に組み合わせたりすると、かえって理解しにくい構造になることもあります。
重要なのは、クラスという文法そのものではなく、変更されやすい処理や共通化すべき責務を、適切な境界でまとめることです。
クラスを使うこと自体を目的にするのではなく、チームで安全に変更できる構造を作るための手段として考える必要があります。

大人数のJavaScript開発で求められているのは、個人の技術力だけに依存しないコードです。
誰か一人が詳細を覚えていなくても、構造を見るだけで処理の役割が分かり、共通部分を安全に再利用できる状態。
JavaScriptクラスは、その土台を作るための有力な選択肢です。
では、そもそもクラスはどのような考え方で設計され、どこまで責務を持たせるべきなのでしょうか。
次は、JavaScriptクラスの基本とオブジェクト指向の考え方から整理していきます。

JavaScriptクラスの基本とオブジェクト指向の考え方

JavaScriptのクラスとオブジェクト指向を表現したコード設計のイメージ

JavaScriptのクラスを理解するには、まず「データ」と「そのデータを操作する処理」を、どのような単位で整理するかという視点を持つことが重要です。
クラスは、この2つをひとつのまとまりとして定義するための仕組みです。
単に記述量を減らすための構文ではなく、プログラムの責務を整理し、同じ設計を繰り返し利用するための枠組みと考えると理解しやすくなります。

たとえば、ユーザーを扱う機能を考えてみましょう。
ユーザーの名前やメールアドレスなどの情報を保持し、その情報を使って表示用の文字列を作る、入力内容を検証する、状態を更新するといった処理が必要になることがあります。
これらを各画面や各モジュールに分散して書いてしまうと、どこに何のロジックがあるのか分かりにくくなります。
クラスを使えば、ユーザーという概念に関係するデータと振る舞いを近い場所にまとめられます。

JavaScriptクラスにおけるデータとメソッドの関係

クラスの中では、オブジェクトが持つ状態をプロパティとして、状態に対して実行する処理をメソッドとして表現します。
たとえば、ユーザー名を保持するnameのようなプロパティと、その名前を利用して表示用の文字列を返すメソッドを同じクラスに定義するイメージです。
ここで大切なのは、データと処理を単純にまとめることではありません。
「このデータに対して責任を持つ処理は何か」を明確にすることです。

この考え方は、オブジェクト指向プログラミングの基本であるカプセル化とも関係します。
カプセル化とは、データや内部処理をひとまとまりにし、外部から必要以上に直接操作させないように設計する考え方です。
JavaScriptでは、すべてを厳密に隠すことだけが目的ではありません。
むしろ、外部から利用してよい操作と、クラス内部で完結させるべき処理の境界を明確にすることが実務上のポイントになります。

たとえば、ユーザーの状態を変更する際に、プロパティをどこからでも直接書き換えられる設計にすると、意図しない値が入る可能性があります。
そこで、変更に関するルールをメソッド側に集約すれば、「どの条件なら変更してよいのか」というロジックを一箇所で管理しやすくなります。
こうした設計は、コードを読んだときの理解にも影響します。
値を変更する処理を探す場合でも、関連するメソッドを確認すればよくなるからです。

コンストラクターとインスタンスをどう捉えるか

JavaScriptのクラスを扱ううえでは、クラスそのものと、クラスから生成されるインスタンスを区別することも重要です。
クラスは設計図のような役割を持ち、インスタンスはその設計に基づいて作られた具体的なオブジェクトです。
同じクラスから複数のインスタンスを生成できるため、共通する構造を一度定義し、それぞれ異なるデータを持つオブジェクトとして再利用できます。

たとえば、アプリケーション内で複数のユーザーを扱う場合、ユーザーごとに同じ構造の処理を個別実装する必要はありません。
クラスを一つ定義しておけば、ユーザーごとのインスタンスを作成し、それぞれの状態を独立して管理できます。
この「共通の構造を一度定義し、必要な数だけ利用する」という考え方が、後で触れる再利用性につながります。

コンストラクターは、インスタンスを生成するときに初期状態を整えるために使います。
外部から受け取った値をプロパティへ設定したり、必要な初期値を決めたりすることで、生成された時点でオブジェクトが成立した状態を作れます。
特に大人数の開発では、「このクラスのインスタンスは最低限どの状態を満たすべきか」が明確であることが重要です。
生成直後の状態が曖昧だと、利用側で個別の初期化処理が増え、結局はコードの重複を招いてしまいます。

オブジェクト指向はクラスを増やすことではない

ここで注意したいのが、「オブジェクト指向だから、とにかくクラスを作る」という考え方です。
これは実務では危険です。
クラスは手段であって、目的ではありません。
単純な変換処理や短いユーティリティ関数まで無理にクラスへまとめると、コードの階層が増え、かえって読みづらくなる場合があります。

オブジェクト指向の本質は、現実世界の物体をそのままクラス化することでも、クラス数を増やすことでもありません。
責務を持つ単位を明確にし、その単位同士の関係を分かりやすく設計することにあります。
JavaScriptでは関数、オブジェクト、モジュール、クラスなど複数の抽象化手段を選べるため、それぞれの特徴を理解したうえで使い分ける姿勢が欠かせません。

大人数の開発では、この判断がさらに重要になります。
ある開発者にとって自然なクラス設計でも、別の開発者には過剰な抽象化に見えるかもしれません。
そこで、クラスを導入するときは「なぜこの責務をここに置くのか」「どの処理を再利用したいのか」「どこから先を外部へ公開するのか」という問いに答えられる状態を目指します。
設計意図を説明できること。
それ自体が、チーム開発における重要な品質です。

JavaScriptクラスを正しく理解すると、クラスは単なる構文ではなく、コードの責務と境界を整理するための設計手段であることが見えてきます。
そして、その価値が最も分かりやすく現れるのが、同じ処理を複数箇所で使う場面です。
共通ロジックをどこに置き、どのように再利用するかを整理できれば、重複コードを減らしながら変更にも強い構造を作れます。
次は、JavaScriptクラスによるコード共通化が、実際の開発でどのようなメリットをもたらすのかを掘り下げていきます。

クラスによるコード共通化で重複を減らすメリット

JavaScriptクラスで共通処理をまとめてコードの重複を減らすイメージ

大人数でJavaScriptを開発していると、似たような処理が少しずつ形を変えながら増えていくことがあります。
たとえば、APIから取得したユーザー情報を整形する処理を、画面Aではその場で記述し、画面Bでは別の関数として実装し、さらに画面Cではコンポーネント内部に直接書いてしまう、といった状態です。
どのコードもその時点では動作していても、同じ目的のロジックが複数箇所に存在すると、後から変更するときに問題が表面化します。

コードの重複で特に厄介なのは、単純にファイル数や行数が増えることではありません。
本質的な問題は、一つの仕様に対して複数の実装が存在する状態になることです。
仕様が変わった場合、すべての実装を探して同じ修正を適用しなければなりません。
一箇所だけ修正を忘れれば、同じ機能なのに動作が異なるという不整合が発生します。
大人数の開発では担当者も入れ替わるため、「この処理が別の場所にもあることを知っている人がいる」という状態に依存する設計は、時間が経つほど危険になります。

重複コードが保守性を下げる理由

コードが重複すると、変更の影響範囲を把握するための調査コストが増えます。
たとえば、入力値の検証ルールを変更するとしましょう。
一つの共通処理として管理されていれば、基本的にはその定義を確認すれば済みます。
しかし、複数画面に同じような検証処理が散らばっていれば、「どこに同じ条件が書かれているのか」を検索しなければなりません。
検索で見つけた箇所が本当にすべてなのかを判断することも、開発者の仕事になります。

さらに、重複したコードは時間とともに分岐していきます。
最初はほぼ同じ内容でも、一方だけに例外処理が追加され、別の箇所では仕様変更に合わせて条件が変わる、といった変化が起こります。
すると、見た目は似ているのに実際の挙動は異なるコードが生まれます。
これはコードレビューでも見落としやすい部分です。
レビュー対象の一部分だけを見ると妥当に見えても、別の場所にある類似実装との整合性までは確認しにくいからです。

クラスで共通処理を集約する効果

このような問題に対して、関連する状態と処理をクラスへ集約するという方法があります。
たとえば、ユーザー情報を加工する責務を一つのクラスにまとめれば、各画面はそのクラスが提供するメソッドを利用するだけで、同じルールに沿った処理を実行できます。
利用側が具体的な内部処理を知らなくてもよいという点も重要です。
必要な操作だけを公開することで、共通化したロジックを安全に使い回しやすくなります。

ここでのポイントは、「コードを一箇所に置く」だけではありません。
共通処理を一つの責務として定義し、利用する側との境界を決めることです。
たとえば、データの形式を整える部分、入力値を検証する部分、表示用の形式へ変換する部分を明確に分ければ、それぞれの処理が何のために存在するのか理解しやすくなります。
クラスが適切な責務を持っていれば、別の機能から同じ処理を利用するときにも、新たな実装を増やす必要がありません。

再利用性が高まると、開発者が「似た処理をまた書く」という作業そのものを減らせます。
これは単なる効率化に見えますが、実際には品質にも影響します。
同じロジックを何度も実装すれば、そのたびに条件分岐の書き間違いや境界値の見落としが起こる可能性があります。
一方、共通化された処理を使えば、基本的なロジックは一箇所で管理できます。
一箇所を十分にテストし、利用側ではその結果を前提に設計できるため、品質担保の考え方も整理しやすくなります。

コード共通化がチーム開発にもたらすメリット

大人数の開発では、共通化の価値は個人の生産性だけでは測れません。
特に大きいのが、開発者間の実装差を抑えられることです。
共通クラスが用意されていれば、新しく機能を担当する開発者は、既存の仕組みを調べて利用できます。
自分なりの方法で似た処理を一から作る必要がありません。
結果として、プロジェクト全体のコードに一定の規則性が生まれます。

これはレビューや保守にも波及します。
たとえば、「ユーザー情報の更新はこのクラスを通して行う」というルールが定着していれば、レビュー時に確認するポイントが明確です。
逆に、同じ処理をどこに書いてもよい状態では、コードレビューのたびに設計判断そのものを議論する必要があります。
自由度が高いように見えて、実際には判断コストが増えてしまうわけです。
共通化は、開発者の自由を奪うためではなく、繰り返し発生する判断を減らすための仕組みとも考えられます。

また、担当者の交代にも強くなります。
個人が頭の中で把握している実装では、その人が離れた瞬間に知識の引き継ぎが難しくなります。
しかし、責務がクラスとして整理され、メソッドの役割や利用方法が明確になっていれば、コードそのものが設計情報として機能します。
ドキュメントだけに依存せず、構造から意図を読み取れる状態です。
長期運用を前提としたシステムでは、この性質が非常に重要になります。

共通化では「何でもクラスにする」必要はない

一方で、コードの重複を見つけたら必ずクラスにまとめる、という考え方も適切ではありません。
短い処理や単純な変換処理までクラス化すると、かえって構造が複雑になる場合があります。
JavaScriptでは関数やモジュールなど、クラス以外にも再利用のための手段があります。
重要なのは、重複を見つけることと、適切な抽象化を選ぶことを分けて考えることです。

特に注意したいのは、表面的に似ているだけのコードを無理に共通化するケースです。
二つの処理が現在は似ていても、将来的に異なる方向へ変更される可能性があります。
その場合、共通化した結果として条件分岐が増え、「Aの場合はこちら、Bの場合はこちら」と例外だらけの設計になることがあります。
共通化の目的は、コードを減らすことそのものではありません。
変更の単位を適切に揃え、同じルールを一貫して適用できるようにすることです。

したがって、クラスによる共通化を検討するときは、「この処理は本当に同じ責務なのか」「変更されるタイミングも同じなのか」「複数の利用箇所で同じ振る舞いを保証したいのか」という観点から判断するとよいでしょう。
構造が似ているからまとめるのではなく、設計上の意味が共通しているからまとめる。
この区別ができると、共通化による恩恵を得ながら、過剰な抽象化も避けやすくなります。

コード共通化の価値は、重複行数を減らすことだけではありません。
変更箇所を集中させ、実装ルールを統一し、テスト対象を整理し、チーム内で知識を共有しやすくすることにあります。
JavaScriptクラスは、そのための一つの有力な手段です。
ただし、本当の価値を引き出すには、どの処理を共通化するのか、どこを責務の境界にするのかを慎重に見極める必要があります。
次は、こうした再利用性をさらに高めるために、JavaScriptクラスをどのように設計すればよいのかを具体的に考えていきます。

JavaScriptクラスの再利用性を高める設計ポイント

JavaScriptクラスを再利用しやすく設計するためのイメージ

JavaScriptクラスを導入しただけで、必ず再利用性が高くなるわけではありません。
むしろ、クラスの中に多くの処理を詰め込みすぎると、別の場所から使いにくい巨大なクラスになってしまいます。
再利用性を高めるためには、「どこからでも使えるクラス」を目指すのではなく、役割が明確で、利用側が必要な機能だけを扱えるクラスとして設計することが重要です。

特に意識したいのが、クラスの責務です。
一つのクラスがデータ取得、入力値の検証、画面表示、ログ出力、エラー処理まで担当してしまうと、最初は便利でも依存関係が急速に増えていきます。
たとえば、APIから取得したデータを扱うクラスに画面固有の表示ロジックまで含めてしまえば、そのクラスを別画面で再利用したくなったときに、不要な処理まで引き連れていくことになります。
再利用しやすい設計では、「このクラスは何をするのか」を一文で説明できる状態が理想です。

クラスの責務を小さく保つ

再利用性を高めるうえで基本となるのが、責務を分離する考え方です。
一つのクラスが一つの目的に集中していれば、利用する側も理解しやすくなり、変更の影響範囲も限定しやすくなります。
これはオブジェクト指向設計で重視される単一責任の考え方とも相性がよいものです。

たとえば、ユーザー情報を取得する処理と、そのユーザーを画面向けに表示する処理は、一見すると関連しています。
しかし、前者はデータ取得という責務、後者は表示という責務です。
将来、同じデータを別の画面やバッチ処理でも使う可能性を考えると、それぞれを分離したほうが再利用しやすくなります。
クラスを設計するときは、「この機能に必要だから全部入れる」のではなく、「このクラスが責任を持つ範囲はどこまでか」という視点が重要です。

また、責務を小さく保つことはテストにも有効です。
役割が限定されたクラスであれば、入力と出力の関係を整理しやすく、テストケースも組み立てやすくなります。
再利用性とテスト容易性は別々の話に見えますが、実際にはかなり強く結び付いています。
扱う責務が明確であるほど、別の場所から安心して利用できるからです。

依存関係を減らして利用しやすくする

クラスの再利用性を左右するもう一つの要素が、外部への依存関係です。
クラス内部から特定の画面要素、特定のフレームワーク、特定のグローバル変数へ直接アクセスする設計では、そのクラスを別の場所へ持っていくことが難しくなります。
再利用したいのに、利用先の環境まで同じであることを要求されるからです。

たとえば、データ処理を行うクラスが内部で特定のDOM要素を直接参照している場合、そのクラスはブラウザ上の特定の画面構造に強く依存します。
同じ処理を別の画面、テスト環境、サーバー側の処理で利用したくなっても、そのままでは使えません。
逆に、必要なデータを引数として受け取り、結果を返すように設計できれば、利用側の環境に左右されにくくなります。

ここで重要なのは、依存関係をゼロにすることではありません。
現実的なソフトウェアでは、外部サービスやライブラリとの接続が必要です。
目指すべきなのは、依存関係を意識して境界を設計することです。
どこまでをクラスの責務とし、どの部分を外部から注入するのかを整理することで、同じクラスを異なる場面で利用しやすくなります。

publicなインターフェースをシンプルにする

再利用する側から見たとき、クラスの内部実装が複雑でも、使い方がシンプルなら問題は大きくありません。
そこで重要になるのが、外部へ公開するインターフェースです。
メソッドの数を増やせば便利になるように見えますが、公開する操作が多すぎると利用者は「どれを使えばよいのか」を判断しなければならなくなります。

大人数の開発では、公開APIを小さく明確にすることが特に有効です。
たとえば、内部では複数の手順を実行していたとしても、利用側には「取得する」「更新する」といった目的に直結した操作だけを提供する方法があります。
利用側が内部の実装手順まで理解する必要がなくなれば、クラスの内部を変更しても、外部への影響を抑えやすくなります。

これはカプセル化の実践的なメリットでもあります。
内部構造を隠すこと自体が目的なのではなく、変更してよい部分と、変更すると利用者に影響する部分を区別できることに価値があります。
再利用されるクラスほど、公開範囲を慎重に設計することが大切です。

継承よりもコンポジションを検討する

JavaScriptでクラスの再利用性を考えると、継承も候補になります。
共通する機能を親クラスにまとめ、複数の子クラスから利用する設計です。
うまく適用できれば重複を減らせますが、継承関係が増えるほどクラス同士の結び付きも強くなります。
そのため、再利用の手段として継承を機械的に選ぶのは避けたほうがよいでしょう。

特に、親クラスの仕様変更が複数の子クラスへ連鎖するような設計では、ある機能を修正しただけなのに予想外の箇所へ影響が出ることがあります。
再利用したい処理が「親子関係」ではなく「部品として組み合わせたい機能」であるなら、別のクラスを保持して必要な処理を委譲するコンポジションのほうが適切な場合があります。

再利用性を高めるという観点では、「何を共有するか」だけでなく、「どのような関係で共有するか」も重要です。
継承は強力ですが、その分だけ設計上の制約も増えます。
共通部分を独立した小さなクラスやモジュールとして切り出し、それを必要な側から組み合わせるほうが、変更に強くなるケースも少なくありません。

状態を持たせすぎないことも重要

クラスの再利用性を考える際には、内部状態の量にも注意が必要です。
状態を大量に保持するクラスは、使い方を理解するまでに時間がかかり、どの操作がどの値へ影響するのかを追跡しにくくなります。
さらに、一つのインスタンスを複数箇所から共有していると、ある処理が状態を書き換えたことによって、別の処理の結果が変わる可能性もあります。

もちろん、状態管理そのものが悪いわけではありません。
クラスの役割として状態を保持することが自然なケースもあります。
重要なのは、その状態が本当にクラスの責務に必要なのかを確認することです。
入力として受け取れる値まで内部へ保存すると、不要な依存が増える場合があります。
状態を必要最小限にし、処理の前提条件を明確にすることで、同じクラスを異なる場面で扱いやすくなります。

命名とインターフェースをチームで統一する

技術的に正しい設計でも、利用方法が開発者によってばらばらなら、再利用性のメリットは十分に発揮されません。
大人数の開発では、クラス名、メソッド名、引数の意味、エラーの扱い方などを一定のルールで揃えることも重要です。
コードを読む側が「この命名なら、この振る舞いだろう」と予測できれば、新しいクラスを利用するときの学習コストを下げられます。

たとえば、あるクラスではデータ取得をget、別のクラスではfetch、さらに別のクラスではloadと表現すると、個々には正しくても、プロジェクト全体では統一感が失われます。
もちろん、語句には文脈による意味の違いがありますが、チーム内で意図を共有できる命名規則を持つことは、再利用性を高めるうえで効果的です。

再利用可能なクラスとは、技術的に何度でも呼び出せるクラスだけではありません。
別の開発者が迷わず使えるクラスでもあります。
そのためにはコードそのものだけでなく、設計ルール、命名規則、ドキュメント、テストといった周辺の仕組みも含めて考える必要があります。

再利用性を高める設計の本質は、クラスを大きくして機能を集約することではありません。
責務を明確にし、依存関係を整理し、公開するインターフェースを小さく保ち、必要な機能だけを組み合わせられる状態を作ることです。
こうした設計ができれば、同じコードを使い回せるだけでなく、仕様変更や機能追加が発生したときにも、どこを修正すべきか判断しやすくなります。
次は、この再利用性が大規模開発の保守性にどのようにつながるのかを、実際のチーム開発という観点から見ていきます。

大規模開発でクラスを使うと保守性が向上する理由

大規模なJavaScript開発でクラスを活用し保守性を高めるイメージ

大規模なJavaScript開発では、機能を追加すること以上に、既存コードを安全に変更し続けられるかどうかが重要になります。
開発初期は数千行程度だったコードベースも、機能追加や不具合修正を重ねることで、数万行、数十万行へと膨らんでいきます。
さらに、開発者の人数が増えるほど、同じコードを全員が完全に理解している状態は難しくなります。
そこで重要になるのが、コードそのものの短さではなく、変更する場所と責任の境界が明確であることです。

クラスを適切に設計すると、関連するデータと処理を一つの単位へまとめられます。
これにより、「この仕様を変更するなら、まずこのクラスを確認する」という見通しを作りやすくなります。
保守性とは、コードがきれいに見えることだけではありません。
将来の自分や別の開発者が、変更箇所を特定し、影響範囲を見積もり、必要な修正を安全に実施できること。
その観点で見ると、クラスによる責務の整理には大きな意味があります。

変更の影響範囲を限定しやすい

ソフトウェアの保守で厄介なのは、一つの変更がどこまで影響するのか分かりにくい状態です。
たとえば、ユーザーの権限判定ルールを変更するとき、判定ロジックが複数の画面や処理に直接書かれていれば、関連箇所を一つずつ探す必要があります。
さらに、見落とした箇所がないか確認するには、コード検索だけでなく実際の動作まで追いかけなければなりません。

一方、権限に関する責務をクラスへ集約していれば、変更の起点を明確にできます。
呼び出し側はクラスが提供するインターフェースを利用するだけにしておけば、内部の判定ロジックを変更しても、利用側のコードまで修正する必要がない場合があります。
もちろん、クラスの設計次第では影響範囲が広がることもあります。
しかし、責務の境界が明確なら、少なくとも「どこを調べるべきか」という探索のコストを下げられます。

これは大規模開発で非常に重要な性質です。
開発者が増えるほど、コードの全体像を把握すること自体が難しくなるからです。
変更対象を局所化できれば、担当者がシステム全体を熟知していなくても、安全に作業できる可能性が高まります。

共通処理を集約して修正漏れを防ぐ

大規模なコードベースでは、同じような処理が複数箇所へコピーされると、保守性が急速に低下します。
たとえば、日付のフォーマット、入力値の検証、APIレスポンスの変換などが画面ごとに実装されているケースです。
仕様変更が発生すると、それぞれの実装を探し、同じ修正を適用しなければなりません。

クラスで共通処理を一元化すれば、この問題を軽減できます。
共通のルールを一つの責務として管理し、そのクラスを各機能から利用する構造にすれば、変更の中心を作れます。
もちろん、共通化した処理が本当に同じ意味を持つことが前提です。
異なる責務を無理に一つへまとめると、クラス内部が条件分岐だらけになり、別の意味で保守性を損ないます。

したがって、クラスによる共通化では「コードが似ているか」だけで判断しないことが大切です。
「この処理は同じ仕様に従って変更されるのか」「今後も同じルールを共有するのか」という観点から、共通化の妥当性を考えます。
共通化の目的は行数削減ではなく、同じ仕様を一つの場所で管理できるようにすることです。

読み手がコードの構造を理解しやすくなる

保守性を考えるとき、見落とされがちなのが可読性です。
コードを修正する前には、まず既存のコードを読んで、その意図を理解する必要があります。
大規模開発では、この「読む時間」が非常に大きなコストになります。

クラスによって責務が整理されていると、コードを読むときの探索単位が明確になります。
ユーザーに関する処理を確認したいならユーザー関連のクラスを見る、注文の状態遷移を調べたいなら注文関連のクラスを見る、といった具合です。
すべての処理が一つの巨大なファイルへ集約されている状態に比べると、必要な情報へ到達しやすくなります。

また、適切な命名がされていれば、クラス名やメソッド名そのものが設計情報になります。
たとえば、「何を管理するクラスなのか」「何を実行するメソッドなのか」が名前から推測できれば、実装の詳細まで読み込む前に全体像を把握できます。
これはコードレビューでも効果的です。
レビュー担当者が処理の境界を理解しやすくなり、仕様と実装の対応関係を確認しやすくなるからです。

テストしやすい構造を作れる

保守性とテスト容易性も密接に関係しています。
クラスの責務が明確であれば、どの条件でどのような結果になるべきかを定義しやすくなります。
逆に、一つのクラスがデータ取得、画面操作、ファイル出力、ログ記録まで担当していると、テストの準備だけで多くの環境や依存関係が必要になります。

たとえば、単純なデータ変換を担当するクラスであれば、必要な入力を与えて期待する結果が返るかを確認しやすいでしょう。
特定のブラウザ画面や外部サービスまで同時に起動しなければテストできない構造と比べると、検証の負担は大きく異なります。

テストしやすいクラスは、変更にも強い傾向があります。
修正した箇所について必要なテストを実行し、期待どおりの結果が得られれば、変更によるリグレッションを確認しやすくなるからです。
大規模開発ではすべてを人手で確認するのは現実的ではありません。
責務を分離し、自動テストで検証しやすい構造を作ることが、長期的な保守コストの抑制につながります。

開発者の入れ替わりに強くなる

大人数のプロジェクトでは、開発メンバーが永続的に同じとは限りません。
新しいメンバーが参加することもあれば、担当者が別のチームへ移ることもあります。
このとき問題になるのが、特定の人しか理解していないコードです。
処理の背景や注意点が開発者の記憶に依存していると、引き継ぎのたびに大きなコストが発生します。

クラスによって責務が整理されていれば、コードそのものが知識の一部として機能します。
「このクラスは何を管理し、どの操作を外部へ提供するのか」が明確なら、新しい開発者でも構造を追いやすくなります。
もちろん、設計書やコメントが不要になるわけではありません。
しかし、コードと設計思想の距離が近いほど、ドキュメントと実装の差異が発生するリスクも抑えやすくなります。

これはチームの規模が大きくなるほど重要です。
数人のチームなら口頭で共有できる情報でも、数十人、数百人規模になれば通用しません。
個人の記憶ではなく、コードの構造や共通ルールによって知識を共有する必要があります。
クラスは、そのための一つの設計単位として機能します。

保守性を高めるにはクラスの境界設計が重要

ここまで見ると、「大規模開発ではクラスを増やせばよい」と考えてしまいそうですが、実際には逆です。
クラスの数よりも、どこで責務を分けるかのほうが重要です。
細かく分割しすぎれば、クラス同士の関係を追いかけるためのコストが増えます。
反対に、一つのクラスへ多くの責務を集めれば、そのクラスが変更の集中点となり、依存関係が複雑になります。

適切な境界を決めるには、その処理が何のために存在するのか、どのタイミングで変更されるのか、誰が利用するのかを考える必要があります。
特に「一緒に変更されるものは近くに置き、異なる理由で変更されるものは分離する」という考え方は、保守性を判断するうえで役立ちます。
単にファイルを分けるのではなく、変更の単位に合わせて責務を設計するわけです。

最終的に目指したいのは、仕様変更が発生したときに「どこを直せばよいのか」が予測できるコードです。
修正箇所が明確で、共通処理が集約され、テストで確認できる。
さらに、担当者が変わっても構造から役割を理解できる。
この状態が作れれば、プロジェクトの規模が大きくなっても、コードを継続的に改善しやすくなります。

JavaScriptクラスは、そのための有力な道具です。
ただし、クラスそのものに保守性を生み出す魔法の効果があるわけではありません。
責務、依存関係、公開インターフェース、テスト容易性といった要素を設計した結果として、クラスが適切に使われていることが重要です。
次は、仕様変更や機能追加が頻繁に発生する現場で、JavaScriptクラスがどのように「変更に強いコード」につながるのかを具体的に考えていきます。

JavaScriptクラスで仕様変更や機能追加に強いコードを作る

JavaScriptクラスを活用して仕様変更に対応しやすいコードのイメージ

ソフトウェア開発では、最初に決めた仕様がそのまま最後まで続くことはほとんどありません。
ユーザーからの要望が追加され、業務ルールが変わり、APIの仕様が更新され、既存機能に例外条件が加わる。
開発期間が長くなるほど、このような変更は自然に発生します。
だからこそ、大規模なJavaScript開発では「今きれいに書けているか」だけでなく、あとから仕様が変わっても修正しやすいかという視点が欠かせません。

この観点でクラスが役立つのは、変更される責務をひとまとまりにし、その内部実装と利用側のコードを分離しやすいからです。
たとえば、ユーザーの状態を判定するルールが変わったとしても、判定を担当するクラスにロジックが集約されていれば、利用側は基本的に同じインターフェースを使い続けられます。
変更を一箇所へ閉じ込められる可能性が高まるわけです。

仕様変更の影響範囲を小さくする

仕様変更に強い設計を考えるとき、最初に見るべきなのが変更の影響範囲です。
たとえば、「一般ユーザーはこの機能を利用できるが、管理者は追加の条件を満たす必要がある」というルールが加わったとします。
権限判定を各画面に直接書いていると、画面ごとに条件を修正しなければなりません。
さらに、将来もう一つ画面が追加されたとき、その画面に同じルールが正しく実装される保証もありません。

そこで、権限判定に関する責務を一つのクラスへ集約します。
各機能は、そのクラスに判定を依頼する構造です。
すると、ルール変更が発生したときの主な変更箇所を権限判定のクラスへ寄せられます。
もちろん、すべての変更を一箇所へ閉じ込められるとは限りません。
インターフェースが変われば利用側の修正も必要です。
しかし、少なくとも個々の画面が独自にルールを持つ状態より、変更箇所の特定は容易になります。

重要なのは、変更しやすさを「コード量の少なさ」と混同しないことです。
短いコードでも、同じ仕様が複数箇所に分散していれば、変更時には大きな負担になります。
一方で、多少コードが増えていても、責務が明確で変更箇所が予測できるなら、保守はしやすくなります。
大規模開発では、記述量よりも変更の局所性を評価するほうが合理的です。

共通ルールをクラスに集約して仕様の一貫性を保つ

仕様変更に伴って起きやすい問題の一つが、機能ごとの挙動のずれです。
たとえば、同じ金額計算のルールを画面Aでは新仕様に更新したのに、画面Bでは旧仕様のまま残ってしまうケースです。
各機能が独立して実装されているほど、この種の不整合は発見しにくくなります。

共通ルールをクラスに集約すると、同じ仕様を利用するコードの入口を統一しやすくなります。
各機能がそれぞれ計算式を持つのではなく、計算を担当するクラスを利用する設計にしておけば、ルールの更新も一箇所から反映しやすくなります。
これはコードの重複を減らすだけではなく、「どの処理が正しい仕様なのか」を明確にする効果もあります。

特に複雑な業務ロジックでは、この違いが大きくなります。
条件分岐が増えれば増えるほど、人間が複数の実装を見比べて完全な整合性を確認することは難しくなります。
共通ロジックとして管理し、同じ処理を同じ実装へ集約することで、仕様の一貫性を維持しやすくなります。

機能追加では既存コードを壊さないことが重要

新機能追加では、「新しい機能を動かす」ことだけに注目してしまいがちです。
しかし、大規模システムでは、既存機能を壊さないことも同じくらい重要です。
既存のクラスが明確な責務を持ち、公開しているインターフェースが安定していれば、その周辺に新しい機能を追加しやすくなります。

たとえば、既存の注文処理クラスが注文の作成という責務だけを持っているなら、新しい割引機能を追加するときにも、注文クラスそのものへ無関係な処理を大量に詰め込む必要はありません。
割引計算を独立した責務として切り出し、必要な場所から組み合わせる方法を検討できます。
こうした設計なら、新機能の追加が既存機能の大規模な書き換えにつながりにくくなります。

これは、クラスを細かく分割すればよいという話ではありません。
細分化しすぎれば、今度はクラス同士の依存関係が増えます。
重要なのは、新しい要求が来たときに、既存の責務を壊さず拡張できる境界があることです。
変更される可能性の高い部分と、比較的安定している部分を見極めながら設計する必要があります。

インターフェースを安定させて内部実装を変更しやすくする

仕様変更に強いコードを作るうえでは、クラス内部の実装と外部から見える使い方を分離することも重要です。
利用側がクラス内部の細かな処理まで知っていると、内部を変更するたびに利用側のコードまで修正しなければならなくなります。
これは抽象化の境界が弱い状態です。

一方で、利用側が必要とする操作だけを提供し、その背後にある処理をクラス内部へ閉じ込めることができれば、内部実装を変更する自由度が上がります。
たとえば、データの取得方法を別のAPIへ切り替えたとしても、外部から見えるメソッドの意味と引数が変わらなければ、利用側の修正を最小限に抑えられる可能性があります。

このとき意識したいのが、「利用者が知る必要のない情報を公開しない」という原則です。
便利そうだからという理由で内部状態や補助的な処理まで公開すると、後からそれらを変更しにくくなります。
一度、多くの箇所から使われ始めたメソッドは、実質的にプロジェクト全体との契約になるからです。
公開APIは少なく、意味を明確にする。
地味ですが、長期運用では強力な設計方針です。

テストを通して仕様変更の安全性を高める

仕様変更に強いコードを作るなら、設計だけでなくテストもセットで考える必要があります。
クラスの責務が整理されていると、そのクラスが満たすべき条件をテストとして定義しやすくなります。
入力に対してどのような結果を返すべきか、どの条件ではエラーにするのか、といった振る舞いを明確にできるからです。

たとえば、料金計算を担当するクラスなら、通常のケースだけでなく、割引条件、上限値、境界値などをテストできます。
仕様変更が入ったときには、新しい条件に合わせてテストを追加・修正し、既存のテストを実行します。
これにより、変更したコードだけでなく、変更によって壊れていないかを継続的に確認できます。

ここで重要なのが、クラスの内部実装ではなく外部から見える振る舞いを中心にテストすることです。
内部の変数名や処理手順まで固定してしまうと、実装を改善するたびにテストも大量に書き換えることになります。
テストは実装を縛るためではなく、仕様を守りながら実装を変えるための安全網として設計するべきです。

機能追加を想定したクラス設計の考え方

将来の機能追加を考えると、現時点で存在しない機能まで過剰に設計したくなることがあります。
「将来必要になるかもしれないから」と、汎用的なオプションや多数の設定値を最初から用意する方法です。
しかし、これは必ずしも良い設計ではありません。
使われていない抽象化は、それだけで理解すべき情報を増やします。

むしろ現時点で確実に存在する責務を明確にし、その責務を壊さずに拡張できる構造を作るほうが現実的です。
将来的な要求が見えた段階で、実際の共通点を確認しながら抽象化する。
ソフトウェア設計では、この順序が重要です。
まだ存在しない問題のために複雑な仕組みを作るより、実際に発生した変更から共通パターンを見つけるほうが、不要な複雑性を避けやすいからです。

大人数のチームでは、こうした判断基準を共有することも重要になります。
「新機能は既存クラスへ追加すべきか」「新しい責務として分離すべきか」「既存インターフェースを変更する価値があるか」といった問いを、担当者ごとの感覚だけで決めるのは危険です。
変更理由と設計意図をコードレビューで確認し、チームとして判断の一貫性を保つ必要があります。

JavaScriptクラスを使うことで、仕様変更や機能追加に伴う影響を一定の範囲へ整理しやすくなります。
ただし、価値があるのはクラスという構文そのものではありません。
責務を分離し、依存関係を制御し、安定したインターフェースを用意し、テストによって振る舞いを保証する。
その設計の積み重ねが、変更に強いコードを作ります。
では次に、こうした設計を大人数の開発チームで運用する際、クラスの責務をどのように共有し、チーム全体で一貫した設計を維持すればよいのかを見ていきましょう。

チーム開発でJavaScriptクラスの責務を明確にする方法

チームでJavaScriptクラスの責務を分担して設計するイメージ

大人数のJavaScript開発では、クラスを作ること以上に「そのクラスが何を担当するのか」をチーム全体で共有することが重要です。
責務が曖昧なまま実装を進めると、ある開発者は便利な処理を追加し、別の開発者は別のクラスへ似た処理を追加するといったことが起こります。
結果として、同じような役割を持つクラスが増え、どこを利用すべきなのか判断しにくいコードベースになります。

特にチーム開発では、個人が頭の中で持っている設計意図を、そのまま共通認識にすることはできません。
だからこそ、クラスの責務をコード構造や命名、インターフェース、レビューのルールなどへ落とし込み、誰が読んでも判断できる状態を作る必要があります。
ここで意識したいのは、「一つのクラスに何でも入れない」という単純なルールだけではありません。
何を変更するときに、どのクラスへ手を入れるべきか予測できることが、本質的な目標です。

クラスの目的を一文で説明できるようにする

最初に取り組みたいのは、クラスの目的を一文で説明することです。
たとえば「ユーザー情報を管理するクラス」「料金を計算するクラス」「APIとの通信を担当するクラス」といった具合です。
もちろん、実際のシステムではもっと複雑な責務を持つ場合もあります。
しかし、説明が一文でできないほど役割が曖昧なら、そこには複数の責務が混ざっている可能性があります。

この考え方は、コードレビューでも有効です。
レビュー時に「このメソッドをここへ追加する理由は何か」と確認したとき、「このクラスの目的に含まれるから」と明確に説明できるなら、責務の境界が比較的はっきりしています。
逆に「ここに置いたほうが便利だから」「関連する処理なので」といった説明しかできない場合は、配置を見直したほうがよいかもしれません。

クラスの役割を言語化することには、もう一つ利点があります。
新しく参加した開発者がコードを理解しやすくなることです。
大規模なプロジェクトでは、すべてのファイルを読んでから開発を始めることはできません。
クラス名と、その役割を説明する短い情報から全体像を把握できれば、必要なコードへ効率よくたどり着けます。

変更理由を基準に責務を分ける

責務を考えるとき、「機能が似ているか」だけで判断すると、クラスが肥大化しやすくなります。
そこで有効なのが、「何が理由でこのコードは変更されるのか」という観点です。
たとえば、画面デザインの変更と料金計算ルールの変更は、どちらも注文画面に関係していても、変更理由はまったく異なります。
この二つを一つのクラスに集めると、関係のない変更まで同じクラスへ集中してしまいます。

反対に、同じ理由で変更される処理を一つの責務としてまとめれば、変更時の探索範囲を小さくできます。
料金計算のルールが変更されたときに料金計算を担当するクラスを確認すればよい、という状態です。
これは保守性だけでなく、レビューのしやすさにもつながります。
変更理由とクラスの責務が対応していれば、「今回の変更で本当にこのクラスだけを修正すればよいのか」という判断をしやすくなるからです。

ここで重要なのは、クラスを機械的に細かく分割することではありません。
変更理由が異なるものを分離し、同じ理由で一緒に変わるものは近くに置く。
その原則を意識するだけでも、責務の境界を設計する精度はかなり上がります。

公開するメソッドを必要最小限にする

チーム内で責務を明確にするには、クラスの内部だけでなく、外部へ何を公開するかも整理する必要があります。
publicなメソッドを増やせば、利用者は多くの操作を直接実行できるようになります。
しかし、その一方で「このメソッドも使ってよいのか」「この状態を書き換えてよいのか」といった判断が利用側へ移ってしまいます。

そこで、クラスの利用者が本当に必要とする操作だけを公開し、内部の補助処理や状態管理はできるだけ隠します。
公開されるメソッドが明確であれば、利用者はクラスの内部設計を理解しなくても利用できます。
また、内部実装を変更したときも、公開インターフェースを維持できれば影響を抑えやすくなります。

大規模開発では、この「公開範囲の制限」が特に重要です。
多くの開発者が利用するクラスほど、一度公開した操作が実質的な契約になります。
必要以上に内部仕様を公開してしまうと、後から削除や変更が難しくなります。
便利だから公開するのではなく、長期的に利用者へ保証できる操作だけを公開する。
この考え方が、責務の境界を安定させます。

クラス間の依存関係を意識する

責務が明確でも、クラス同士が複雑に依存していれば、実際の保守は難しくなります。
AクラスがBクラスを利用し、BクラスがCクラスを利用し、さらにCクラスがAクラスへ依存するような構造になると、変更の影響を追跡することが難しくなります。
責務分離は、単に処理を別ファイルへ移すことではなく、依存関係も含めて設計する必要があります。

特に注意したいのが、何でも一つのクラスから直接呼び出す構造です。
あるクラスがデータベース、HTTP通信、画面操作、ログ管理など、多数のクラスへ直接依存していると、そのクラスの変更やテストが難しくなります。
責務を分けたうえで、必要な依存だけを持たせることが重要です。

また、依存関係の方向も意識するとよいでしょう。
上位の業務ロジックが具体的な画面実装へ強く依存してしまうと、画面変更が業務ロジックへ波及します。
反対に、環境に依存しにくい処理を中心へ置き、外側から必要な機能を組み合わせる設計にすれば、変更の影響を限定しやすくなります。
完全な依存ゼロを目指すのではなく、依存関係を把握できる形に整えることが現実的です。

命名規則で責務をコードに表現する

チーム開発では、命名も設計の一部です。
クラス名やメソッド名から役割が読み取れれば、コードを開く前からある程度の構造を推測できます。
逆に、曖昧な名前や広すぎる名前を使うと、クラスにどこまで処理を追加してよいのか分かりにくくなります。

たとえば、「Manager」「Helper」「Utility」のような名前は便利に見えますが、具体的な責務を表現しにくい傾向があります。
もちろん文脈によって適切な場合もありますが、何を管理し、何を変換し、何を提供するクラスなのかが名前から分かるほうが、チームで扱いやすくなります。

同様に、メソッド名も「何をするか」を表現する必要があります。
メソッド名を読んだだけで、副作用があるのか、値を返すのか、状態を変更するのかを推測できる設計なら、利用者の誤解を減らせます。
命名規則は一見すると細かなルールですが、大規模コードベースでは非常に大きな差になります。
コードそのものがチーム共通のドキュメントとして機能するからです。

コードレビューで責務の境界を確認する

責務を明確にするためには、実装時だけでなくレビュー時にも設計を確認する必要があります。
コードレビューを単なるバグ探しとして扱うのではなく、「この処理はどこに置くべきか」「既存クラスの責務に含まれるのか」「新しいクラスとして分離すべきか」という設計判断の場として活用します。

特に大人数のチームでは、レビューを通して判断基準を共有することに価値があります。
ある担当者が「この程度なら既存クラスへ追加する」と判断したのに、別の担当者が「これは別責務だ」と考えるなら、将来的にコード構造が不統一になります。
すべてを細かなルールにする必要はありませんが、責務分離の基準をチーム内で議論し、繰り返し使うことが大切です。

レビューで注目したいのは、行数や書き方の好みだけではありません。
変更理由、依存関係、公開インターフェース、再利用性、テスト容易性など、将来の保守に影響する観点です。
こうした観点を共有できれば、クラスの責務が個人の経験や好みに左右されにくくなります。

ドキュメントとテストで責務を補強する

コードだけで責務が完全に伝わらない場合は、短いドキュメントを添えることも有効です。
ただし、長大な設計書を作ることが目的ではありません。
「このクラスは何を担当するのか」「何をしてはいけないのか」「どのように利用するのか」といった重要な情報を簡潔に示します。

さらに、テストも責務を可視化する役割を持ちます。
あるクラスのテストが入力を受け取り、特定の条件で特定の結果を返すことを保証しているなら、そのテストケース自体がクラスの責務を示す資料になります。
逆に、一つのクラスのテストをするために大量の外部環境を準備しなければならない場合は、責務が広すぎる可能性があります。

このように、命名、コード構造、レビュー、ドキュメント、テストを組み合わせることで、クラスの責務をチームの共通認識として定着させやすくなります。
どれか一つに頼るのではなく、複数の手段で同じ設計意図を表現することがポイントです。

大人数のJavaScript開発で求められるのは、「このクラスには何でも入れられる」という柔軟性ではありません。
誰が担当しても判断に迷いにくく、「この処理はここに置く」「この操作はこのインターフェースを通す」と説明できる構造です。
責務が明確になれば、コードの再利用性が上がるだけでなく、変更箇所の予測、レビュー、テスト、引き継ぎまで一貫して改善しやすくなります。
次は、こうした設計を意識する一方で、JavaScriptクラスを使いすぎることでかえって複雑になるケースにも目を向け、クラスを使わないほうがよい場面を整理していきます。

JavaScriptクラスの使いすぎに注意すべきケース

JavaScriptクラスを適切に使い分ける設計判断のイメージ

ここまで見てきたように、JavaScriptクラスはコードの再利用性や責務の整理に役立つ強力な仕組みです。
ただし、だからといって、コードを見つけるたびにクラスへ変換すればよいわけではありません。
クラスは抽象化のための手段であり、導入することで構造が複雑になるのであれば、本来の目的から外れてしまいます。
特に大人数の開発では、設計の複雑さそのものがチーム全体のコストになるため、クラスを使わないほうが合理的な場面も見極める必要があります。

クラスの使いすぎで起こりやすい問題は、まず「何をするコードなのか」を理解するための負担が増えることです。
単純な処理であれば、関数を一つ読むだけで済むものを、クラス、コンストラクター、インスタンス、メソッド、依存関係と追っていかなければならなくなることがあります。
抽象化には価値がありますが、問題の大きさに対して抽象化のコストが高すぎると、かえって可読性を損ないます。

単純な処理までクラス化しない

代表的なのが、入力を受け取って結果を返すだけの単純な処理です。
たとえば、文字列を整形したり、数値を変換したり、配列から特定の値を取り出したりする程度の処理であれば、クラスにまとめる必然性はあまりありません。
こうした処理は状態を持たないことが多く、関数として定義したほうが「何を渡すと何が返るのか」を直接理解できます。

クラスにすると、まずインスタンスをどう生成するのか、どのメソッドを呼ぶのか、初期状態は必要なのかといった概念が追加されます。
処理そのものは数行なのに、それを利用するための構造が大きくなる状態です。
これは抽象化の典型的なオーバーヘッドです。
コード量だけでなく、読み手が理解すべき概念が増えることにも注意が必要です。

特にチーム開発では、「処理が小さいからクラスにする」のではなく、「状態や責務を持つ独立した単位として扱う必要があるからクラスにする」と考えるほうが整理しやすくなります。
関数で十分表現できる処理に対して、無理にオブジェクト指向の構造を持ち込む必要はありません。

状態を持たない処理は関数のほうが分かりやすい

クラスの強みは、データと振る舞いを関連付けたり、インスタンスごとの状態を扱ったりできることです。
裏を返せば、状態をまったく必要としない処理では、その強みが活きにくい場合があります。
入力された値から結果を計算するだけの処理なら、関数として切り出したほうが利用方法が単純です。

たとえば、税込価格を計算する処理や、文字列を正規化する処理などは、基本的に入力と出力の関係だけで考えられます。
このような処理までクラス化すると、「このクラスは何の状態を持っているのか」「なぜインスタンスを生成する必要があるのか」という余計な疑問が生まれます。
設計上の理由を説明できないクラスは、時間が経つほど負債になりやすいものです。

もちろん、最初は単純な関数でも、将来的に状態管理や複数の関連操作が必要になるケースはあります。
その場合は、実際に必要性が発生した時点でクラス化を検討すればよいでしょう。
未来の可能性だけを理由に先回りして抽象化するより、現実の変更に合わせて設計を進化させるほうが、結果としてシンプルなコードを維持しやすくなります。

クラスを増やしすぎると依存関係が複雑になる

大規模開発では、クラスの数が増えること自体よりも、クラス同士の関係が複雑になることが問題です。
AクラスがBクラスを利用し、BクラスがCクラスを利用し、さらにCクラスが別のサービスへ依存する、といった関係が多数生まれると、変更時に追跡すべき経路が増えます。

特に、ひとつの機能を実現するために大量の小さなクラスを連携させる設計では、「結局どこを見ればこの処理が分かるのか」が分かりにくくなることがあります。
責務分離のために作ったクラスが、逆に処理の流れを分断してしまうわけです。

この問題を避けるには、クラスの数ではなく、理解しやすい単位になっているかを基準にすることが重要です。
小さく分けることが常に正義ではありません。
関連性が強く、ほぼ必ず一緒に変更される処理なら、無理に分離しないほうが読みやすい場合もあります。
設計とは分割することではなく、適切な境界を決めることだと捉えると判断しやすくなります。

継承を重ねすぎる設計には注意する

JavaScriptのクラスを使うと、継承によるコード再利用を検討する場面も出てきます。
親クラスへ共通処理を集め、子クラスで固有の振る舞いを追加する方法です。
うまく使えば便利ですが、継承階層が深くなると、コードの理解が難しくなります。

たとえば、あるメソッドが現在のクラスに定義されているのか、親クラスから受け継いだものなのか、さらにその親にあるのかを追跡する必要が出てきます。
親クラスの変更が複数の子クラスへ影響する可能性もあります。
コードを再利用できても、変更の予測が難しくなれば、保守性という観点では逆効果です。

「共通部分があるから親クラスにする」という発想だけで継承を始めるのではなく、「この二つは本当に同じ種類のオブジェクトとして扱う必要があるのか」と考えることが大切です。
単に処理を共有したいだけなら、別クラスを組み合わせる方法や関数を共有する方法のほうが適している場合があります。

データ構造にまでクラスを使う必要はあるのか

JavaScriptには、オブジェクト、配列、Map、Setなど、データを表現するための仕組みがもともと用意されています。
そのため、単に複数の値をひとまとめに持ちたいだけなのに、専用クラスを新しく定義する必要があるとは限りません。

たとえば、一時的な画面データや設定値のように、単純な構造を持つだけのデータなら、通常のオブジェクトで十分なケースがあります。
そこへクラスを導入すると、定義ファイルが増え、生成方法を覚える必要が生まれます。
もちろん、データに検証や状態変更などの明確な振る舞いが加わるなら、クラスを検討する価値が出てきます。

判断の基準は、「そのデータが処理上の概念として独立しているか」です。
値を入れて持ち運ぶだけなのか、それとも、そのデータに対して一貫したルールや操作を提供したいのか。
この違いを意識すると、必要以上のクラス化を避けやすくなります。

フレームワークやライブラリの設計方針も考慮する

JavaScript開発では、利用するフレームワークやライブラリによって、クラス中心の設計が適している場合と、そうでない場合があります。
たとえば、コンポーネントや状態管理を特定の方式で構築するフレームワークでは、その思想に合わせたほうがチーム全体の理解が容易です。

プロジェクトの標準が関数ベースなのに、一部だけ独自にクラス中心の設計へすると、コードベース全体の一貫性が崩れることがあります。
逆に、既存システムがクラスを中心に設計されているなら、関数だけで無理に統一しようとする必要もありません。
重要なのは、単独の設計思想を絶対視することではなく、プロジェクト全体で一貫したルールを維持することです。

大人数の開発では、個々のコードが最適であることより、チームが同じ前提でコードを読めることのほうが重要になる場合があります。
クラスを導入するときも、「技術的に可能か」だけでなく、「現在のプロジェクトで自然か」「既存コードと整合するか」を確認する必要があります。

クラス化するか判断するための視点

実務で迷ったときは、次のような問いを使うと判断しやすくなります。

  • この処理は状態を持つ必要がありますか?
  • 複数の関連する操作を一つの責務として扱う必要がありますか?
  • 同じ設計を複数のインスタンスで再利用したいですか?
  • クラスにすることで、利用者の理解や変更作業が本当に楽になりますか?
  • 関数やモジュールなど、もっと単純な手段で同じ目的を達成できませんか?

これらを確認して、クラス化による設計上の利益が明確なら導入を検討します。
反対に、「何となくオブジェクト指向だから」「将来使うかもしれないから」といった理由しかないなら、まずはシンプルな実装を選ぶほうが安全です。

クラスの価値は、クラスという形式そのものにはありません。
問題を適切な単位でモデル化し、状態や責務を整理し、再利用性と保守性を高められることに価値があります。
だからこそ、使う場面だけでなく、使わない場面も理解しておく必要があります。
クラスを適切に使い、不要なところでは関数やモジュールを選ぶ。
この柔軟な判断こそが、長期的に扱いやすいJavaScriptコードにつながります。
次は、クラスと関数をどのような基準で使い分ければよいのかを整理し、実際の設計判断につなげていきます。

関数とJavaScriptクラスを使い分ける判断基準

JavaScriptで関数とクラスを使い分ける設計比較のイメージ

JavaScriptで再利用可能なコードを書くとき、「関数にするべきか、クラスにするべきか」で迷う場面は少なくありません。
どちらも処理を整理し、複数箇所から利用するための手段ですが、得意としている問題は異なります。
特に大人数の開発では、個々の開発者がその場の好みで選択すると、同じコードベースの中に異なる設計思想が混在し、後から理解するコストが増えてしまいます。
重要なのは、どちらが優れているかを決めることではなく、扱うデータ、状態、責務、変更単位に応じて適切なほうを選ぶことです。

関数は、入力を受け取って処理を行い、結果を返すという形で考えやすいのが特徴です。
特に、状態を内部に保持する必要がなく、同じ入力に対して同じルールで結果を求めるような処理では、関数が自然な選択になります。
一方、クラスはデータと、そのデータを操作する複数の振る舞いを一つの単位として扱いたい場合に適しています。
さらに、インスタンスごとに異なる状態を保持しながら、共通のメソッドを再利用したい場面でも力を発揮します。

関数を選ぶべき場面

まず、処理が単純で状態を持たないのであれば、関数を第一候補にするとよいでしょう。
たとえば、文字列の整形、数値の変換、配列の加工、入力値のチェックなどです。
これらは「何を渡したら何が返るか」という関係を明確に表現できるため、関数と相性がよい処理です。

関数の大きな利点は、利用するための前提条件が少ないことです。
クラスのようにインスタンスを生成する必要がなく、必要な値を引数として渡すだけで処理を実行できます。
呼び出し側のコードだけを見ても処理の流れを追いやすいため、読み手が理解すべき概念を増やしにくいというメリットがあります。

また、関数はテストもしやすい傾向があります。
外部状態への依存が少なく、入力と出力の関係が明確なら、個別の条件をテストケースとして切り出しやすくなります。
大規模開発では、小さな処理を無理にクラスへまとめるより、単純なものは単純なまま維持するほうが、コード全体の認知負荷を下げられる場合があります。

クラスを選ぶべき場面

一方で、処理に状態があり、その状態を複数の関連メソッドから一貫して扱いたい場合は、クラスのメリットが大きくなります。
たとえば、あるユーザーの状態を保持しながら、情報を更新したり、権限を確認したり、表示用データを生成したりするケースです。
これらを単独の関数だけで管理すると、関連するデータを毎回引数として渡す必要が増えたり、状態の整合性を利用側で管理したりすることがあります。

クラスであれば、インスタンスが状態を保持し、その状態を操作するメソッドを近い場所へまとめられます。
利用側からすると、「ユーザーに対してこの操作をする」という自然なモデルを作りやすくなります。
特に同じ構造のオブジェクトを複数生成し、それぞれ独立した状態を持たせたい場合には、クラスの考え方が分かりやすくなります。

また、複数のメソッドが共通の前提条件を持つ場合にもクラスは有効です。
あるメソッドだけでは完結せず、「この状態になっていること」が別のメソッドを使う条件になるような処理では、クラスに状態と振る舞いをまとめることで、利用方法を整理できます。
ただし、状態を持つからといって必ずクラスにする必要はありません。
クロージャやモジュールなど、別の方法で同じ設計を実現できることもあります。

再利用したいのは処理か、それとも状態を持つモデルか

関数とクラスを使い分けるときに便利なのが、「何を再利用したいのか」という問いです。
再利用したいのが単一の処理であれば、関数で十分なことが多いです。
反対に、「この種類のデータには、この一連の操作が常に付随する」という設計なら、クラスとしてモデル化する価値が高まります。

たとえば、ある文字列を一定のルールで正規化するだけなら、正規化関数を共有すれば済みます。
しかし、設定を保持しながら複数の形式へ変換したり、変換前後の状態を管理したりするなら、クラスとしてまとめたほうが利用者の意図を表現しやすくなる場合があります。

つまり、再利用性そのものがクラス専用のメリットではありません。
関数も十分に再利用可能です。
重要なのは、再利用する対象の粒度に合わせて抽象化することです。
単一の計算をクラスにする必要はありませんし、複数の状態と振る舞いが密接に結び付いているものを無理に分解する必要もありません。

変更のされ方を基準に選ぶ

もう一つ重要な判断材料が、将来的な変更のされ方です。
たとえば、ある計算式だけが変更されるなら、その計算を関数として独立させておくほうがシンプルかもしれません。
一方、状態管理や関連する複数の操作がまとめて変更されるのであれば、それらをクラスの責務としてまとめたほうが、変更箇所を追いやすくなります。

大規模開発では、「現在どう動くか」だけでなく、「何が変更理由になるか」を意識することが重要です。
変更理由が異なるものを一つのクラスへ押し込むと、そのクラスがさまざまな事情で変更されるようになります。
反対に、一緒に変更される可能性が高い処理を適切な単位へまとめれば、保守の見通しを改善できます。

この観点から見ると、関数とクラスの選択は文法の問題ではなく、設計上の境界をどこへ置くかという問題です。
どちらを使うか迷ったら、「このコードは将来どのような理由で変更されるだろうか」と考えてみると判断しやすくなります。

チーム開発では一貫した判断基準を持つ

大人数のプロジェクトでは、個々の開発者が毎回ゼロから判断しないことも重要です。
「状態を持たない変換処理は関数にする」「複数の関連操作と状態を一つの概念として扱う場合はクラスを検討する」といった基準を共有しておけば、実装方針がぶれにくくなります。

これは単なるコーディング規約とは少し違います。
目的は、判断そのものを軽くすることです。
コードレビューで「なぜクラスなのか」「なぜ関数ではないのか」という議論が毎回ゼロから始まる状態では、チームの時間を消費します。
設計上の原則を共有しておけば、議論をより本質的な問題へ進められます。

また、既存コードとの一貫性も無視できません。
新しい機能だけ最新の設計思想に合わせても、周囲のコードと大きく異なれば、かえって読みづらくなることがあります。
設計を改善するときは、新旧の方式が混在するコストも考え、必要に応じて段階的に移行することが現実的です。

迷ったときは最小限の抽象化から始める

関数とクラスのどちらを選ぶか迷ったとき、最初から将来のすべてを予測する必要はありません。
むしろ、現時点で確実に必要な責務だけを表現し、実際の変更や再利用のパターンを見ながら抽象化を育てるほうが、過剰設計を避けやすくなります。

たとえば、最初は単純な関数として実装し、後から状態管理や複数の関連操作が増えてきた段階でクラス化するという進め方があります。
逆に、すでに状態を持つ明確なモデルがあり、複数箇所で同じ振る舞いを共有することが分かっているなら、最初からクラスを採用する合理性があります。

設計の良し悪しは、「最初から完璧に未来を予測したか」では決まりません。
実際の要求に対して、必要以上の複雑さを持ち込まず、それでいて変更しやすい構造を維持できるかどうかです。
関数もクラスも、その目的を達成するための道具にすぎません。

最終的には、状態の有無、責務のまとまり、再利用する単位、変更理由、チーム内の一貫性という複数の観点から判断するのがよいでしょう。
関数を選べばシンプルになり、クラスを選べば再利用性が高まる、と単純化するのではなく、「このコードにとって最も理解しやすく、変更しやすい抽象化は何か」と考えることが本質です。

ここまで整理してくると、JavaScriptクラスは万能な解決策ではない一方で、適切な境界を作ることで大規模開発の再利用性と保守性を強く支えられることが分かります。
次は、これまでの内容を踏まえて、クラスを活用したコード共通化を大人数の開発でどのように実践していけばよいのかを、記事全体の流れとしてまとめていきます。

大人数のJavaScript開発で再利用性と共通化を実現するまとめ

JavaScriptクラスで再利用性とコード共通化を実現する開発のまとめ

ここまで、JavaScriptクラスが大人数の開発において、なぜ再利用性やコード共通化に役立つのかを整理してきました。
ポイントを一言でまとめるなら、クラスの価値は「コードを短くすること」ではなく、同じ責務を同じ場所で管理し、チーム全体で安全に再利用できる構造を作ることにあります。

大規模な開発では、機能が増えるほどコードの量も開発者の人数も増えていきます。
その結果、同じ処理が複数箇所へコピーされたり、担当者ごとに微妙に異なる実装が増えたりします。
こうした状態では、仕様変更が発生したときに修正漏れが起きやすくなり、どのコードが正しい実装なのか判断するコストも高くなります。
クラスを適切に使って責務を集約すれば、共通ロジックを一つの単位として管理し、複数の機能から同じルールを利用しやすくできます。

再利用性を高める鍵は責務の明確化

再利用性を考えるうえで最も重要なのは、クラスを増やすことではありません。
そのクラスが何を担当するのかを明確にすることです。
ユーザー管理、料金計算、権限判定、データ変換など、独立した役割を適切な単位にまとめることで、利用側は必要な機能だけを使えるようになります。

反対に、一つのクラスへ多くの責務を詰め込むと、最初は便利でも徐々に扱いづらくなります。
画面表示、API通信、データ検証、ログ出力などが一つのクラスに集まれば、変更理由が増え、依存関係も複雑になります。
再利用しやすいクラスとは、何でもできるクラスではありません。
目的と責任の範囲がはっきりしていて、別の場所から見ても使い方を予測しやすいクラスです。

さらに、クラスの内部実装と外部から使うインターフェースを分けることも重要です。
利用者に必要な操作だけを公開すれば、内部の実装を改善したり、処理方法を変更したりしても、利用側への影響を抑えやすくなります。
つまり、再利用性とは「何度でも呼び出せること」だけではなく、「内部を知らなくても安全に使えること」でもあります。

コード共通化は変更コストの削減につながる

コード共通化のメリットは、同じコードを書かなくて済むことだけではありません。
本当に大きいのは、仕様変更に伴う修正箇所を集約しやすくなることです。
同じルールが複数箇所へ分散していると、変更のたびにすべての実装を探し、同じ修正を適用しなければなりません。
一箇所でも漏れれば、機能によって結果が異なるという不整合につながります。

共通処理を適切なクラスへ集約できれば、「この仕様はこのクラスが担当する」という変更の起点を作れます。
もちろん、クラスを使えばすべての変更が一箇所で済むわけではありません。
しかし、責務が整理されていれば、どこを確認すべきかを判断しやすくなります。
これは大人数の開発において非常に重要です。
すべての開発者がシステム全体を把握しているわけではないからです。

特に長期運用されるシステムでは、変更の頻度が高い部分と、比較的安定している部分を適切に分離することが保守性に直結します。
コードの行数が少ないことよりも、変更の影響範囲を予測できることのほうが、実務では価値があります。

大人数のチームでは設計ルールの共有が重要

クラス設計の恩恵を最大限に活かすには、個々の開発者がそれぞれ好きな方法でクラスを書くのではなく、チームとして一定の判断基準を持つことが重要です。
どのような場合にクラスを使い、どのような処理なら関数にするのか。
どこまでを一つの責務とし、どのメソッドを外部へ公開するのか。
こうした考え方が共有されていれば、コードレビューや新機能の設計でも判断がぶれにくくなります。

ここで重要なのは、「すべてをクラスにする」というルールではありません。
状態を持たない単純な変換処理や計算処理なら、関数のほうが自然な場合があります。
一方、複数の関連する操作と状態を一つの概念として管理するなら、クラスが有効です。
関数とクラスを対立するものとして考えるのではなく、問題に対して適切な抽象化を選ぶことが大切です。

また、クラス名やメソッド名をチームで一貫させることも、再利用性を高めます。
新しく参加した開発者がコードを読んだとき、名前から責務を推測できれば、理解のために大量のコードを追跡する必要がありません。
命名、レビュー、テスト、ドキュメントといった仕組みが組み合わさることで、クラスの設計意図がチーム全体へ共有されやすくなります。

クラスを使いすぎないことも設計品質の一部

ここまでクラスのメリットを説明してきましたが、クラスを増やすほどよいわけではありません。
単純な処理までクラス化すると、かえって理解すべき概念が増えます。
継承を深くしすぎれば、メソッドがどこから提供されているのか追いにくくなります。
小さな責務へ分割しすぎれば、クラス同士の依存関係が増えて処理の流れが見えにくくなることもあります。

したがって、クラスを導入するときは、「この処理をクラスとして扱うことで、何が改善されるのか」を説明できることが重要です。
状態管理が必要なのか、複数の関連操作をまとめる意味があるのか、同じ構造を複数のインスタンスで再利用したいのか。
こうした理由が明確ならクラス化する価値があります。
反対に、単にオブジェクト指向だからという理由だけで導入するなら、まず関数やモジュールで十分かを検討したほうがよいでしょう。

最も大切なのは、クラスという文法を使うことではなく、変更しやすく、読みやすく、再利用しやすいコード構造を作ることです。
クラスはそのための有力な道具ですが、唯一の道具ではありません。

JavaScriptクラスを活用するときに意識したいこと

実際の開発で今回の考え方を活かすなら、まず既存コードの重複や責務の混在を観察するところから始めるとよいでしょう。
同じ処理が何度も登場しているなら、それは共通化を検討するサインです。
ただし、表面的に似ているだけなら無理にまとめず、「同じ理由で変更される処理か」という観点から判断します。

そのうえでクラスとして切り出す場合は、次のような点を意識すると設計しやすくなります。

  • クラスの責務を一文で説明できるようにする
  • 外部へ公開する操作を必要最小限にする
  • 特定の画面や環境への依存を必要以上に持たせない
  • 状態を持たせる理由を明確にする
  • 共通化した処理にはテストを用意する
  • 関数で十分な処理まで無理にクラス化しない

このような視点を持っておくと、コード共通化が単なるリファクタリングではなく、チーム全体の開発基盤を整える作業として見えてきます。

大人数のJavaScript開発では、誰か一人が効率よくコードを書くことだけでは、プロジェクト全体の品質を長期間維持できません。
誰が担当しても既存の仕組みを再利用でき、仕様変更が起きても修正箇所を予測でき、新しいメンバーが参加してもコードの責務を理解しやすいことが重要です。
JavaScriptクラスは、そのための設計単位として大きな力を発揮します。

最終的に目指すべきなのは、「クラスを使ったコード」ではありません。
「共通化すべきものが共通化され、分離すべきものが分離され、変更理由に応じて責務が整理されているコード」です。
その結果としてクラスが適切に配置されていれば、再利用性、保守性、可読性、品質担保を同時に高めやすくなります。

JavaScriptのクラスを学ぶときは、構文だけを覚えて終わりにしないことが重要です。
どこに責務を置くのか、何を共通化するのか、どの境界を安定させるのか。
そこまで考えてこそ、クラスの本当の価値が見えてきます。
大人数で育てるJavaScriptコードだからこそ、個々の実装ではなく、チーム全体で再利用できる設計を意識すること。
それが、長く保守できるコードベースを作るための重要な一歩です。

コメント

タイトルとURLをコピーしました