クラスはもういらない?TypeScriptでオブジェクト指向を脱却し関数と型定義でスマートに開発する極意

TypeScriptでクラスから脱却し関数と型定義でスマートに開発する極意を象徴するアイキャッチ画像 プログラミング言語

TypeScriptを用いた開発において、クラスベースのオブジェクト指向は長らく主流の設計手法でした。
しかし、近年のフロントエンドやNode.js界隈では、あえてクラスを避け、関数と型定義を中心に据えるアプローチが注目を集めています。
なぜでしょうか。
それは、クラスが本質的に抱えるいくつかの問題点、すなわち継承階層の複雑化、thisの束縛に関する混乱、そしてテストのしにくさといった課題が、規模の拡大とともに顕在化しやすいからです。

  • 継承よりもコンポジションを優先する設計原則は、関数と型の組み合わせで自然に実現できます
  • 純粋関数は副作用がなく、単体テストが容易で、予測可能な振る舞いを保証します
  • TypeScriptの構造的型付けは、クラスの名前的型付けよりも柔軟で、疎結合な設計を促進します
  • 状態と振る舞いを分離することで、コードの見通しが良くなり、変更に強いモジュールが作れます

もちろん、クラスを完全に否定するわけではありません。
適材適所です。
しかし、多くのビジネスロジックやデータ処理においては、関数と型定義によるアプローチのほうが、コード量を抑えつつ意図を明確に表現できる場面が少なくありません。
たとえば、以下のような型と関数の組み合わせを見てください。

type User = { id: string; name: string; age: number };

const createUser = (id: string, name: string, age: number): User => ({ id, name, age });

const isAdult = (user: User): boolean => user.age >= 18;

このスタイルでは、データ構造は型で定義し、操作は独立した関数として定義します。
クラスのインスタンスメソッドのように暗黙のthisに依存せず、引数と戻り値の型がすべてを語ります。
結果として、関数は他の関数と自由に組み合わせ可能で、テストも容易です。

本記事では、TypeScriptでオブジェクト指向から脱却し、関数と型定義を中心としたスマートな開発を実践するための具体的な極意を解説します。
クラス設計で悩んだ経験のある方にとって、新たな視点と実践的な指針を提供できるはずです。

  1. なぜ今、TypeScriptでクラスを手放すのか
    1. 関数型プログラミングの普及とパラダイムの変化
    2. 構造的型付けとクラスの相性の悪さ
    3. バンドルサイズとツリーシェイキングの観点
    4. テスト容易性と副作用の分離
    5. 変化の速い要件への適応力
  2. クラスベースのオブジェクト指向が抱える本質的な課題
    1. 継承階層の深淵化がもたらす保守コストの増大
    2. this束縛と状態管理が生むテストの困難さ
  3. 関数と型定義で実現するコンポジション指向の設計
    1. TypeScriptの構造的型付けがもたらす柔軟性
    2. 純粋関数と不変データで予測可能なコードを書く
  4. 型定義を中心に据えたドメインモデリングの実践
    1. ユニオン型と判別共用体で状態遷移を安全に表現する
    2. 関数合成とパイプラインで処理を組み立てる
  5. クラスと関数型アプローチの使い分け判断基準
    1. 状態の有無とライフサイクルで判断する
    2. 継承の必要性とポリモーフィズムの表現方法
    3. チームの習熟度とコードベースの一貫性
  6. テスト容易性と依存注入を関数でシンプルに解決する
    1. 依存注入の本質と関数による実現
    2. 高階関数による振る舞いの注入
    3. テストダブルを関数でシンプルに表現する
  7. 実践例で学ぶ関数と型定義によるリファクタリング
    1. リファクタリング前のクラスベース実装
    2. 型定義によるドメインの明確化
    3. 純粋関数への分割と状態の分離
    4. リファクタリングの効果を検証する
  8. よくある誤解とアンチパターンを避けるために
    1. 誤解その1:クラスは完全に悪であり、すべて関数にすべき
    2. 誤解その2:関数型とはつまりメソッドチェーンのこと
    3. アンチパターン:過度な抽象化と型の乱用
    4. アンチパターン:状態を隠蔽しすぎる
  9. まとめ:クラスに依存しないTypeScript開発の新たな標準

なぜ今、TypeScriptでクラスを手放すのか

TypeScriptのクラス設計を見直す開発者が増えている背景を表したイメージ

TypeScriptはJavaScriptに静的型付けをもたらす言語として広く普及しました。
その普及の過程で、多くの開発者がJavaやC#といったクラスベースの言語の経験をそのまま持ち込み、TypeScriptでもクラスを中心とした設計を採用してきました。
しかし、ここ数年で、あえてクラスを避け、関数と型定義を中心に据える開発スタイルが注目を集めています。
なぜ、このような潮流が生まれているのでしょうか。
その背景には、言語仕様、エコシステム、そして開発現場の要求の変化という、複数の要因が絡み合っています。

関数型プログラミングの普及とパラダイムの変化

第一の要因は、関数型プログラミングの考え方がフロントエンドやバックエンドの現場に広く浸透したことです。
Reactをはじめとする多くのライブラリが、コンポーネントを関数として定義するスタイルを推奨しています。
また、Reduxのような状態管理ライブラリも、純粋関数と不変データを前提とした設計を採用しています。
こうしたエコシステムの中で、クラスは次第に浮いた存在になりつつあります。
関数型の考え方に慣れた開発者にとって、クラスのインスタンスメソッドやthisの扱いは、むしろ余計な複雑さとして映るのです。

構造的型付けとクラスの相性の悪さ

第二の要因は、TypeScriptの型システムが構造的型付けを採用している点です。
構造的型付けとは、型の互換性を名前ではなく構造で判断する仕組みです。
この仕組みは、関数やオブジェクトリテラルを用いた設計と非常に相性が良い一方で、クラスベースの設計とは必ずしも噛み合いません。
たとえば、クラスのprivateフィールドは名前的な要素を型に持ち込み、構造的型付けの利点を損ないます。
結果として、クラスを使うほどに型の再利用が難しくなり、かえって冗長なコードを生むことがあります。

バンドルサイズとツリーシェイキングの観点

第三の要因は、フロントエンド開発におけるバンドルサイズの最適化です。
クラスはプロトタイプベースの継承を持つため、バンドラによる不要コードの削除、いわゆるツリーシェイキングが関数に比べて効きにくいという側面があります。
関数として定義されたコードは、参照されていなければ容易に削除できますが、クラスのメソッドはプロトタイプに紐づくため、静的な解析が難しくなる場合があります。
パフォーマンスを重視する現場では、この違いが無視できません。

テスト容易性と副作用の分離

第四の要因は、テストのしやすさです。
クラスは状態と振る舞いをカプセル化しますが、その状態がテストを難しくすることがあります。
インスタンスを生成し、メソッドを呼び出し、内部状態を検証するという手順は、純粋関数を呼び出して戻り値を検証するよりも、どうしても記述量が増えがちです。
関数と型定義を中心に据えれば、副作用を端に追いやり、ロジックの大半を純粋関数として切り出せます。
結果として、テストコードは簡潔になり、リファクタリングの安心感も高まります。

変化の速い要件への適応力

第五の要因は、現代のソフトウェア開発が置かれた環境そのものです。
要件は頻繁に変わり、マイクロサービスやサーバーレスのように、小さな単位で機能を組み合わせる設計が一般化しました。
こうした環境では、継承階層を積み上げるよりも、小さな関数と型を組み合わせて柔軟に再構成できるほうが有利です。
クラスは変更に対して閉じた構造を作りやすく、一度肥大化すると分解が困難になります。

もちろん、クラスが不要だと言っているわけではありません。
状態を持ち、ライフサイクルを管理するような対象、たとえばデータベース接続やストリーム処理などでは、クラスが適している場面も依然としてあります。
しかし、アプリケーションロジックの大部分は、関数と型定義で十分に表現できます。
むしろそのほうが、意図が明確で、テストしやすく、変更に強いコードになります。
だからこそ今、TypeScriptでクラスを手放すという選択が、現実的な設計戦略として支持されているのです。

クラスベースのオブジェクト指向が抱える本質的な課題

クラス継承の複雑化やthis束縛の混乱など設計上の問題点を象徴する図

クラスベースのオブジェクト指向は、長年にわたり多くの言語で標準的な設計手法として採用されてきました。
カプセル化、継承、ポリモーフィズムという三本柱は、確かに強力な抽象化の手段です。
しかし、TypeScriptのような言語で大規模なアプリケーションを構築する際、これらの仕組みがかえって開発を難しくする場面が少なくありません。
ここでは、クラス設計が抱える本質的な課題を、継承と状態管理という二つの観点から整理してみます。

継承階層の深淵化がもたらす保守コストの増大

継承は、コードの再利用を実現する仕組みとして広く知られています。
しかし、継承を重ねるほどに階層は深くなり、それぞれのクラスがどの振る舞いを引き継ぎ、どこで上書きしているのかを把握するのが難しくなります。
この状態は、しばしば深い継承ツリーや脆い基底クラス問題と呼ばれ、変更のたびに予期しない影響が連鎖する原因となります。

たとえば、基底クラスに新たなメソッドを追加したとしましょう。
一見すると無害な変更ですが、派生クラスの中で同名のメソッドが既に定義されていれば、意図せず振る舞いが上書きされてしまいます。
このような問題は、コードを書いた本人でさえ気づかないことがあり、発見が遅れるほど修正コストは跳ね上がります。

  • 継承は「is-a」関係を強制するため、本来は委譲で済む関係まで階層に押し込んでしまう
  • 派生クラスは基底クラスの実装詳細に依存し、基底の変更が派生の破壊につながる
  • 多重継承を避けるためのインターフェース乱立が、かえって見通しを悪くする

結果として、継承階層は「再利用のための仕組み」であるはずが、「変更を恐れるための仕組み」に変質していきます。
これが保守コストの増大につながるのです。

this束縛と状態管理が生むテストの困難さ

クラスのもう一つの課題は、thisの束縛と内部状態の管理です。
JavaScriptおよびTypeScriptにおけるthisは、呼び出し方によって参照先が変わるという言語仕様を持っています。
この仕様は、メソッドをコールバックとして渡したり、イベントハンドラに登録したりする際に、しばしば予期しない挙動を引き起こします。
アロー関数で束縛を固定する方法もありますが、それは根本的な解決ではなく、コードの至るところにbindやアロー関数が散らばる原因になります。

さらに深刻なのは、クラスが内部状態を持つがゆえに、テストが複雑になる点です。
テストを書くには、まずインスタンスを生成し、必要な状態をセットアップし、メソッドを呼び出し、その後の内部状態を検証するという手順を踏みます。
この一連の流れは、純粋関数のテストと比べて明らかに記述量が多く、テスト間で状態が共有されると順序依存が生まれます。

class Counter {
  private count = 0;
  increment() { this.count++; }
  getCount() { return this.count; }
}

このようなクラスをテストする場合、incrementを呼ぶたびに内部状態が変化するため、テストの実行順序に注意を払わなければなりません。
一方、関数と不変データで同じロジックを表現すれば、入力と出力の関係だけを検証すればよくなります。
テストの困難さは、そのままリファクタリングの心理的な障壁となり、コードの品質を長期的に損なう要因になるのです。

関数と型定義で実現するコンポジション指向の設計

関数と型定義を組み合わせて疎結合な設計を表現した概念図

クラスベースの設計が抱える課題を踏まえると、次に検討すべきは代替となる設計手法です。
ここで中心となる考え方が、コンポジション指向、すなわち小さな部品を組み合わせて全体を構築するアプローチです。
継承のように「親子関係」で振る舞いを引き継ぐのではなく、独立した関数と型を必要に応じて組み合わせることで、柔軟で再利用性の高いコードを実現します。
TypeScriptは、このコンポジション指向の設計を支える二つの強力な特徴を備えています。
構造的型付けと、純粋関数を書きやすい言語仕様です。

TypeScriptの構造的型付けがもたらす柔軟性

TypeScriptの型システムは、構造的型付けを採用しています。
これは、型の互換性を名前ではなく、その型が持つプロパティやメソッドの構造によって判断する仕組みです。
クラスベースの言語に見られる名前的型付けとは対照的であり、この違いが設計の自由度に大きく影響します。

構造的型付けの利点は、ある関数が必要とする構造を満たしていれば、それがクラスのインスタンスであれ、オブジェクトリテラルであれ、別の型であれ、引数として受け入れられる点にあります。
つまり、特定のクラスに依存することなく、必要な形だけを型として定義すればよいのです。
次の例を見てください。

type HasName = { name: string };

const greet = (entity: HasName): string => `Hello, ${entity.name}`;

このgreet関数は、HasNameという構造さえ満たしていれば、どんなオブジェクトでも受け取れます。
クラスを定義する必要はありませんし、継承関係を気にする必要もありません。
関数と型定義だけで、疎結合な設計が自然に実現できるのです。
この柔軟性は、テスト用のモックオブジェクトを用意する際にも大きな効果を発揮します。

純粋関数と不変データで予測可能なコードを書く

コンポジション指向の設計を支えるもう一つの柱が、純粋関数と不変データです。
純粋関数とは、同じ入力に対して常に同じ出力を返し、副作用を持たない関数を指します。
不変データとは、一度生成したら内容を変更しないデータのことです。
この二つを組み合わせることで、コードの振る舞いが予測可能になり、テストやデバッグが容易になります。

クラスのメソッドは、しばしば内部状態を書き換える副作用を持ちます。
しかし、純粋関数は状態を変更せず、新しい値を返すだけです。
たとえば、配列に要素を追加する操作を考えてみましょう。
破壊的なpushではなく、スプレッド構文を使って新しい配列を返すようにします。

const addItem = <T>(list: readonly T[], item: T): T[] => [...list, item];

このaddItemは元の配列を変更せず、常に新しい配列を返します。
呼び出し元は、元のデータが書き換わる心配をせずに済みます。
結果として、関数の振る舞いが入力だけに依存し、実行順序や共有状態に左右されなくなります。
これは、並行処理や非同期処理が絡む現代のアプリケーションにおいて、極めて重要な性質です。

コンポジション指向の設計では、こうした小さな純粋関数を組み合わせて、より大きな処理を組み立てます。
それぞれの関数が独立しているため、再利用が容易で、変更の影響範囲も限定されます。
クラスの継承階層に悩まされることなく、必要な部品を必要なだけ組み合わせる。
これが、関数と型定義によるスマートな開発の本質なのです。

型定義を中心に据えたドメインモデリングの実践

型定義を中心にビジネスドメインをモデリングする手法の概念図

コンポジション指向の設計を実際のアプリケーションに適用する際、その出発点となるのがドメインモデリングです。
ドメインモデリングとは、業務上の概念やルールをコード上でどう表現するかを設計する作業を指します。
クラスベースの設計では、概念をクラスとして定義し、状態と振る舞いを一つにまとめるのが一般的でした。
しかし、型定義を中心に据えるアプローチでは、まずデータの形を型として定義し、その上で操作を関数として組み立てます。
この順序が、見通しの良い設計につながります。

ユニオン型と判別共用体で状態遷移を安全に表現する

ドメインモデリングにおいて頻繁に直面するのが、状態遷移の表現です。
たとえば、注文は「未確定」「確定済み」「発送済み」「キャンセル済み」といった複数の状態を持ち、それぞれで扱える操作が異なります。
クラスでこれを表現しようとすると、状態を表すフラグをいくつも持たせたり、状態ごとにサブクラスを作ったりと、かえって複雑になりがちです。

TypeScriptでは、ユニオン型と判別共用体を使うことで、状態遷移を型安全に表現できます。
判別共用体とは、共通の判別用プロパティを持つ複数の型をユニオンでまとめたものです。
次の例を見てください。

type Order =
  | { status: "pending"; items: string[] }
  | { status: "confirmed"; items: string[]; confirmedAt: Date }
  | { status: "shipped"; items: string[]; trackingId: string }
  | { status: "cancelled"; reason: string };

このOrder型は、statusプロパティの値によって四つの状態を判別できます。
switch文でstatusを分岐させれば、TypeScriptの型 narrowing が働き、それぞれの状態で存在するプロパティだけに安全にアクセスできます。
存在しないプロパティを参照しようとすれば、コンパイル時にエラーとなります。
つまり、不正な状態遷移を型レベルで防げるのです。

  • 状態ごとに必要なデータだけを持たせられるため、無効な組み合わせが生まれない
  • 分岐の網羅性をコンパイラがチェックするため、状態の追加漏れを防げる
  • クラスのサブクラス階層に比べて、状態の追加や変更が容易である

関数合成とパイプラインで処理を組み立てる

型定義でデータの形を定めたら、次はそのデータを変換する処理を組み立てます。
ここで活躍するのが関数合成とパイプラインの考え方です。
関数合成とは、小さな関数を組み合わせてより大きな関数を作る手法です。
パイプラインは、データを一連の関数に順番に通していくスタイルを指します。

たとえば、注文データを検証し、割引を適用し、合計金額を計算する処理を考えてみましょう。
それぞれを独立した純粋関数として定義し、順番に適用します。

const validate = (order: Order): Order => { /* 検証処理 */ return order; };
const applyDiscount = (order: Order): Order => { /* 割引適用 */ return order; };
const calculateTotal = (order: Order): number => { /* 合計計算 */ return 0; };

const processOrder = (order: Order): number =>
  calculateTotal(applyDiscount(validate(order)));

このスタイルの利点は、各関数が独立してテストでき、必要に応じて順序を入れ替えたり、関数を差し替えたりできる点にあります。
クラスのメソッドチェーンと似て見えますが、決定的な違いは、各関数が状態を持たず、thisにも依存しないことです。
処理の流れがデータの流れとして明示され、どこで何が起きているかが一目で分かります。

関数合成とパイプラインは、可読性と保守性を両立させる強力な手法です。
型定義と組み合わせることで、データの形と処理の流れの両方が型によって保証され、安心してリファクタリングできる基盤が整います。

クラスと関数型アプローチの使い分け判断基準

クラス設計と関数型設計を状況に応じて使い分ける判断基準の比較イメージ

ここまで、TypeScriptにおいてクラスを手放し、関数と型定義を中心に据える設計手法を見てきました。
しかし、これはクラスを完全に否定するものではありません。
重要なのは、どちらが適しているかを見極める基準を持つことです。
設計手法は目的ではなく手段です。
課題に対してどの抽象化が最も適しているかを、論理的に判断する必要があります。
ここでは、クラスと関数型アプローチをどのように使い分けるべきか、その判断基準を整理します。

状態の有無とライフサイクルで判断する

最初の判断軸は、扱う対象が状態を持つかどうかです。
状態を持ち、その状態が時間とともに変化し、さらに外部リソースとの接続のようなライフサイクルを伴う場合、クラスは有効な選択肢になります。
たとえば、データベース接続、ファイルハンドル、WebSocketのセッションなどが該当します。
これらは生成から破棄までの期間があり、途中で状態が変化します。
クラスのカプセル化は、こうしたリソースの管理を一箇所にまとめるのに向いています。

一方、状態を持たない、あるいは入力から出力への変換が中心の処理は、関数型アプローチが適しています。
ビジネスロジックの大半、データの変換、バリデーション、計算処理などは、純粋関数として表現できます。
状態を持たない関数は、呼び出し順序に依存せず、テストも容易です。

判断軸 クラスが適する 関数型が適する
状態 状態を持ち変化する 状態を持たない
ライフサイクル 生成と破棄がある 都度呼び出して完結する
外部リソース 接続やハンドルを管理する 引数として受け取る
テスト セットアップが必要 入力と出力だけで検証できる

継承の必要性とポリモーフィズムの表現方法

第二の判断軸は、継承関係が必要かどうかです。
クラスベースの設計では、共通の振る舞いを基底クラスにまとめ、派生クラスで差分を表現します。
しかし、この継承は諸刃の剣です。
階層が深くなれば保守コストが増大します。
本当に継承が必要な場面は、実際にはそれほど多くありません。

多くの場合、ポリモーフィズムは継承ではなく、ユニオン型と判別共用体、あるいはインターフェースと関数の組み合わせで表現できます。
たとえば、複数の種類の図形の面積を計算する処理は、クラスの継承階層を作るよりも、判別共用体で図形の種類を表現し、種類ごとに関数を用意するほうが簡潔です。
継承は「is-a」関係を強制しますが、コンポジションは「has-a」や「uses-a」の関係を自然に表現できます。

チームの習熟度とコードベースの一貫性

第三の判断軸は、チームの習熟度と既存コードの一貫性です。
どれほど理論的に優れた手法でも、チームが理解し、維持できなければ意味がありません。
JavaやC#の経験が長いメンバーが多いチームでは、クラスベースの設計のほうが意図が伝わりやすい場合もあります。
逆に、Reactや関数型の経験が豊富なチームでは、関数と型定義のアプローチが自然に受け入れられます。

また、既存のコードベースとの一貫性も無視できません。
既存コードがクラス中心であれば、新規部分だけ関数型にしても、かえって混乱を招くことがあります。
段階的に移行する、あるいは明確な境界を設けて使い分けるといった戦略が現実的です。
設計手法の選択は、純粋に技術的な問題ではなく、組織やプロジェクトの文脈に依存する経営的な判断でもあるのです。

結論として、クラスと関数型アプローチは対立するものではなく、補完し合うものです。
状態とライフサイクルを持つ対象にはクラスを、変換と計算が中心の処理には関数を。
この原則を軸に、チームの状況とコードベースの文脈を加味して判断する。
それが、TypeScriptでスマートに開発を進めるための現実的な指針になります。

テスト容易性と依存注入を関数でシンプルに解決する

関数による依存注入とテスト容易性の向上を表したシンプルな図解

ソフトウェア設計において、テストのしやすさは品質を左右する重要な要素です。
どれほど優れた機能でも、テストが困難であれば、変更のたびに大きなリスクを伴います。
クラスベースの設計では、依存関係をコンストラクタで注入する依存注入が一般的な手法として用いられてきました。
しかし、関数と型定義を中心に据えるアプローチでは、依存注入をよりシンプルに、そして自然に実現できます。
ここでは、その仕組みと利点を整理します。

依存注入の本質と関数による実現

依存注入とは、あるモジュールが利用する外部の依存関係を、内部で生成するのではなく外部から渡す設計手法です。
この手法の目的は、依存関係を差し替え可能にし、テスト時にモックやスタブを注入できるようにすることにあります。
クラスでは、コンストラクタの引数として依存を受け取るのが典型的です。

関数型アプローチでは、依存は単純に関数の引数として受け取ります。
特別な仕組みは不要です。
たとえば、現在時刻を取得する処理を考えてみましょう。
クラスであれば、時刻を返すサービスをコンストラクタで注入しますが、関数であれば、時刻を返す関数そのものを引数として受け取れば済みます。

type Clock = () => Date;

const isExpired = (expiresAt: Date, clock: Clock): boolean =>
  expiresAt.getTime() < clock().getTime();

このisExpired関数は、現在時刻を直接new Date()で取得するのではなく、clockという関数を通じて取得します。
テスト時には、固定の時刻を返す関数を渡せばよいのです。
クラスもインターフェースも不要で、依存関係が型として明示され、差し替えが容易になります。

高階関数による振る舞いの注入

関数型アプローチの強みは、依存の注入が高階関数、すなわち関数を引数に取る関数によって自然に表現できる点です。
ログ出力、エラーハンドリング、リトライ処理といった横断的な関心事は、高階関数で包み込むことで、本体のロジックから分離できます。

たとえば、非同期処理にリトライ機構を追加したい場合を考えます。
クラスであれば、リトライ用の基底クラスやデコレータを用意することになるでしょう。
関数であれば、リトライ回数と対象の関数を受け取る高階関数を一つ定義するだけで済みます。
本体のロジックはリトライの存在を知らずに済み、テストも個別に実施できます。

  • 依存は引数として明示されるため、何に依存しているかが一目で分かる
  • テスト時にはモック関数を渡すだけでよく、専用のテストダブルを用意する必要が少ない
  • 高階関数によって横断的関心事を分離でき、本体のロジックが純粋に保たれる
  • 依存の差し替えが関数の受け渡しだけで完結し、DIコンテナのような仕組みが不要になる

テストダブルを関数でシンプルに表現する

テストにおいては、モック、スタブ、スパイといったテストダブルを用意する場面が頻繁にあります。
クラスベースの設計では、これらを生成するためにモックライブラリの助けを借りたり、インターフェースを実装した専用クラスを作ったりすることがあります。
しかし、関数型アプローチでは、テストダブルの多くが単なる関数として表現できます。

スタブは固定値を返す関数、スパイは呼び出しを記録する関数、モックは期待される呼び出しを検証する関数です。
これらはいずれも、数行のコードで定義できます。
型定義があれば、テストダブルが本物の依存と同じシグネチャを持つことをコンパイラが保証してくれます。
結果として、テストコードは短くなり、意図が明確になります。

テスト容易性は、設計の良し悪しを映す鏡です。
関数と型定義を中心に据えた設計は、依存注入を特別な仕組みなしに実現し、テストを自然な営みに変えます。
クラスのコンストラクタ注入に煩わしさを感じていたなら、関数の引数として依存を渡すスタイルを試してみる価値は十分にあります。

実践例で学ぶ関数と型定義によるリファクタリング

既存のクラス設計を関数と型定義へリファクタリングする実践例のイメージ

理論を学んだら、次は実践です。
ここでは、典型的なクラスベースのコードを、関数と型定義によるアプローチへとリファクタリングする具体例を見ていきます。
題材として、ユーザー登録と認証を扱うシンプルなモジュールを取り上げます。
クラスで書かれたコードが抱える問題点を確認し、それを段階的に関数型へと移行する過程を通じて、実践的な勘所を掴んでいきましょう。

リファクタリング前のクラスベース実装

まず、リファクタリング前のコードを見てみます。
ユーザーを管理するクラスが、登録、認証、パスワード検証といった複数の責務を一手に引き受けている状態です。

class UserService {
  private users: Map<string, string> = new Map();

  register(email: string, password: string): boolean {
    if (this.users.has(email)) return false;
    this.users.set(email, password);
    return true;
  }

  authenticate(email: string, password: string): boolean {
    return this.users.get(email) === password;
  }

  isValidEmail(email: string): boolean {
    return /^[^@]+@[^@]+\.[^@]+$/.test(email);
  }
}

このクラスには複数の問題があります。
第一に、usersという可変の内部状態を持ち、テストのたびにインスタンスを生成しなければなりません。
第二に、isValidEmailのような純粋な検証ロジックが、状態を持つクラスに同居しています。
第三に、認証と登録という異なる関心事が一つのクラスに混在し、単一責任の原則に反しています。

型定義によるドメインの明確化

リファクタリングの第一歩は、ドメインの概念を型として明示することです。
ユーザー、認証結果、エラーといった概念を型で表現します。
これにより、関数のシグネチャが意図を語るようになります。

type Email = string & { readonly __brand: "Email" };
type User = { readonly email: Email; readonly password: string };
type AuthResult = { ok: true } | { ok: false; reason: string };

Email型はブランド型と呼ばれる手法で、単なるstringではなく、検証済みのメールアドレスであることを型レベルで表現しています。
AuthResultは判別共用体で、成功と失敗を型安全に扱えます。
こうした型定義により、関数が何を受け取り、何を返すのかが明確になります。

純粋関数への分割と状態の分離

次に、クラスの責務を純粋関数へと分割します。
検証ロジックは状態を持たない純粋関数として独立させ、状態の管理は呼び出し側、あるいは専用のデータ構造に委ねます。

const isValidEmail = (value: string): value is Email =>
  /^[^@]+@[^@]+\.[^@]+$/.test(value);

const authenticate = (
  users: ReadonlyMap<Email, User>,
  email: Email,
  password: string
): AuthResult =>
  users.get(email)?.password === password
    ? { ok: true }
    : { ok: false, reason: "認証情報が一致しません" };

authenticateは、ユーザーの集合を引数として受け取ります。
内部状態を持たないため、テスト時には任意のマップを渡すだけで済みます。
認証ロジックそのものが純粋になり、入力と出力の関係だけを検証できるようになりました。

リファクタリングの効果を検証する

リファクタリングの前後で、何が変わったのかを整理してみましょう。

観点 リファクタリング前 リファクタリング後
状態 クラス内部に保持 引数として外部から渡す
テスト インスタンス生成が必要 関数を直接呼び出せる
責務 複数が混在 関数ごとに分離
型の意図 曖昧 ブランド型と共用体で明確

この変化により、コードの見通しが良くなり、テストが簡潔になり、変更の影響範囲も限定されます。
重要なのは、一度にすべてを書き換えるのではなく、純粋なロジックから順に切り出していく点です。
検証ロジック、変換ロジック、計算ロジックといった副作用のない部分は、比較的容易に関数化できます。
状態を持つ部分は後回しにし、必要に応じてクラスやクロージャとして残せばよいのです。
段階的なリファクタリングこそ、現実的な移行の鍵となります。

よくある誤解とアンチパターンを避けるために

関数型アプローチで陥りやすい誤解やアンチパターンへの注意を促す図

関数と型定義を中心とした設計は強力ですが、正しく理解せずに導入すると、かえって可読性や保守性を損なうことがあります。
ここでは、クラスを手放す際に陥りやすい誤解と、関数型アプローチでよく見られるアンチパターンを取り上げます。
これらを事前に知っておくことで、無用な回り道を避けられます。

誤解その1:クラスは完全に悪であり、すべて関数にすべき

最もよく見られる誤解は、クラスを全面的に否定し、あらゆるコードを関数に置き換えようとする姿勢です。
しかし、これは設計の目的を見失った本末転倒な考え方です。
クラスが適している領域は確かに存在します。
状態を持ち、ライフサイクルを管理し、外部リソースをカプセル化する対象、たとえばデータベース接続やストリーム処理、ステートフルなサービスなどは、クラスで表現するほうが自然で安全です。

  • すべてを関数にすると、状態管理が呼び出し側に散らばり、かえって複雑になる
  • リソースの解放漏れを防ぐ仕組みが失われ、バグの温床になる
  • チームの習熟度を無視した全面移行は、生産性を一時的に大きく低下させる

重要なのは、クラスか関数かという二項対立ではなく、対象の性質に応じて適切に選ぶことです。

誤解その2:関数型とはつまりメソッドチェーンのこと

第二の誤解は、関数型アプローチを「クラスのメソッドを関数に置き換え、パイプラインでつなぐだけ」と捉えることです。
確かにパイプラインは関数型の便利な表現ですが、本質はそこではありません。
関数型の核心は、純粋性と不変性にあります。
関数が副作用を持たず、データが変更されないからこそ、合成や並列処理が安全に行えるのです。

メソッドチェーンの見た目だけを真似ても、各関数が内部状態を書き換えたり、グローバル変数を参照したりしていれば、関数型の利点は得られません。
見た目ではなく、セマンティクスを理解することが重要です。

アンチパターン:過度な抽象化と型の乱用

関数型の考え方を学んだ直後に陥りやすいのが、過度な抽象化です。
汎用性を求めるあまり、意味のない高階関数を量産したり、型レベルプログラミングに没頭したりするケースがあります。
しかし、抽象化は目的ではなく手段です。
読み手が意図を理解できない抽象化は、たとえ理論的に美しくても価値がありません。

また、型を過剰に使い込むのも考えものです。
ブランド型や条件型を多用しすぎると、コードは堅牢になる代わりに、理解と保守が困難になります。
型は安全性を高めるための道具であり、複雑さを増やすためのものではありません。
シンプルさを保つことが、長期的な生産性につながります。

アンチパターン:状態を隠蔽しすぎる

関数型アプローチでは、状態を引数として明示的に渡すことが推奨されます。
しかし、これを徹底しすぎると、多数の関数に同じ状態を引き回すことになり、引数のリストが膨大になります。
これは引数の地獄と呼ばれるアンチパターンです。

この問題への対処は、状態を完全に排除することではなく、適切にまとめることです。
関連する状態を一つの型にまとめ、その型を引数として渡せば、引数の数は抑えられます。
また、どうしても多数の関数で共有すべき文脈がある場合は、クロージャや専用のコンテキストオブジェクトを活用するのも有効です。
純粋性を保つことと、実用性を両立させるバランス感覚が求められます。

結論として、関数と型定義による設計は、銀の弾丸ではありません。
誤解とアンチパターンを避け、対象の性質とチームの文脈に合わせて適用することが、成功への鍵になります。

まとめ:クラスに依存しないTypeScript開発の新たな標準

クラスに依存せず関数と型定義でスマートに開発する新たな標準のイメージ

本記事では、TypeScriptにおいてクラスを手放し、関数と型定義を中心に据える設計手法を解説してきました。
ここで、これまでの議論を振り返り、実践への道筋を整理します。

出発点は、クラスベースのオブジェクト指向が抱える本質的な課題でした。
継承階層の深淵化は保守コストを増大させ、this束縛と内部状態の管理はテストを困難にします。
これらの問題は、コードの規模が大きくなるほど顕在化し、変更を恐れる開発体制を生み出します。

次に、代替となるコンポジション指向の設計を見ました。
TypeScriptの構造的型付けは、名前ではなく構造で型の互換性を判断するため、クラスに依存しない柔軟な設計を可能にします。
純粋関数と不変データを組み合わせれば、振る舞いが予測可能になり、テストとリファクタリングが容易になります。
型定義を中心に据えたドメインモデリングでは、ユニオン型と判別共用体によって状態遷移を型安全に表現し、関数合成とパイプラインで処理を組み立てます。

ただし、クラスを完全に否定するわけではありません。
状態を持ち、ライフサイクルを管理し、外部リソースをカプセル化する対象には、クラスが適しています。
判断基準は、状態の有無、ライフサイクルの有無、そしてチームの習熟度とコードベースの一貫性です。
この基準に照らして、適材適所で使い分けることが重要です。

依存注入も、関数型アプローチでは特別な仕組みを必要としません。
依存を関数の引数として渡し、高階関数で横断的関心事を分離する。
テストダブルも単なる関数として表現できるため、テストコードは簡潔になります。
実践例で見たように、純粋なロジックから段階的に切り出すことで、無理なく移行できます。

  • 状態とライフサイクルを持つ対象にはクラスを使う
  • 変換と計算が中心の処理には関数と型定義を使う
  • 純粋性と不変性を保ち、副作用は端に追いやる
  • 抽象化と型の使用は、シンプルさを保つ範囲にとどめる

誤解とアンチパターンも確認しました。
クラスの全面否定、見た目だけの関数型、過度な抽象化、状態の隠蔽しすぎは、いずれも避けるべきです。
目的は理論的な美しさではなく、読みやすく、変更に強く、テストしやすいコードを書くことです。

クラスに依存しないTypeScript開発は、もはや一部の先進的な開発者だけの手法ではありません。
関数と型定義を中心に据える設計は、現代のアプリケーション開発が求める柔軟性と安全性に応える、新たな標準となりつつあります。
まずは小さな関数から。
既存のコードの中で純粋なロジックを切り出すところから始めてみてください。
その一歩が、保守しやすく拡張しやすいコードベースへの入口になります。

コメント

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