TypeScriptの継承で共通化に悩むエンジニア必見!コンポジションを活用した型安全なコード共通化手法

TypeScriptのコンポジションと継承を比較するアイキャッチ画像。型安全なコード共通化手法を示す図解。 プログラミング言語

TypeScriptにおけるコード共通化の実現手段として、多くのエンジニアがまず挙げるのがクラスの継承でしょう。
確かに、extendsキーワードは直感的に振る舞いを引き継ぐ仕組みを提供しますが、複雑なドメインモデルや頻繁な仕様変更が伴う現場では、深い継承階層が技術的負債を生み出す原因となりがちではないでしょうか。
親クラスと子クラスの密結合、意外と気づきにくいLiskov置換原則の違反、そして複数の関心事を横断する処理の実装困難。
これらはオブジェクト指向設計における古典的な課題であり、TypeScriptの型システムの中でも同様の摩擦が発生します。

そこで本記事では、継承に代わる柔軟な共通化手法としてコンポジションを取り上げます。
コンポジションは、「has-a」関係に基づいて機能を組み合わせる設計アプローチであり、単一継承の制約を受けず、テストの容易性と型安全性を両立させることが可能です。
特にTypeScriptのインターフェス、型エイリアス、および交叉型を活用することで、実行時のオーバーヘッドを伴わずに、厳格な型チェックの下で振る舞いを合成できます。

以下では、継承が抱える構造的な問題を型レベルで分析し、コンポジションを用いた具体的な実装パターンと、それがもたらす設計上の優位性を検証していきます。
型の流れを意識した堅牢な設計の実現。
それが本記事の目的です。

  1. TypeScriptの継承がもたらす設計上の課題と型安全性のトレードオフ
  2. 継承の限界が型安全性を損なう3つの具体的なケース
    1. 基底クラスとの密結合が引き起こす変更リスクとテストの困難さ
    2. 単一継承の制約と複数の関心事を横断する実装の柔軟性の欠如
    3. Liskov置換原則違反の発生パターンと型チェックでは捕まえきれない落とし穴
  3. コンポジションとは?継承に代わる柔軟なコード共通化手法の基礎
    1. has-a関係に基づく設計思想の本質と関心事の分離
    2. TypeScriptのインターフェスと交叉型による型安全な振る舞いの合成
  4. TypeScriptで実現するコンポジションの実装パターン3選
    1. ミックスインによる振る舞いの型安全な注入と再利用
    2. 委譲パターンによる責務の分離とクラス間の疎結合化
    3. ファクトリ関数とオブジェクト合成による柔軟な初期化と型推論
  5. 継承からコンポジションへのリファクタリング実践ガイド
    1. 既存コードの継承階層を分析し問題点を特定する手順
    2. 段階的な移行戦略と型の互換性を維持するためのポイント
  6. コンポジションが有効な実務シナリオと型設計のベストプラクティス
    1. UIコンポーネントの横断的関心事を型安全に分離する手法
    2. ドメインモデルにおける機能の組み合わせと不変条件の保証
  7. 継承とコンポジションの使い分け基準:is-aとhas-aの判断フレームワーク
    1. オブジェクト関係の見極め方と設計指針の策定
    2. チーム開発で共有すべきコーディング規約とアーキテクチャ基準の具体例
  8. 型安全な設計選択が長期的な生産性と保守性を左右する

TypeScriptの継承がもたらす設計上の課題と型安全性のトレードオフ

TypeScriptの継承の課題を示すアイキャッチ。型安全性と密結合の問題を視覚化したイメージ。

クラスベースのオブジェクト指向設計において、継承は最も直感的に学ばれ、そして最も安易に用いられがちな仕組みの一つです。
TypeScriptにおいても、extendsキーワードは既存のクラスの振る舞いを子クラスへ引き継ぐ強力な手段を提供します。
型システムは親クラスで定義されたプロパティとメソッドの存在を子クラスに対しても保証し、コンパイル時の型チェックを通じて一貫性を担保する。
これは一見すると、型安全性とコードの再利用性を両立させる理想的な解に見えるでしょう。

しかしながら、実際のソフトウェア開発、特に要件の変化が常態化した中規模以上のアプリケーションにおいて、深い継承階層はしばしば設計の柔軟性を著しく損ないます。
ここでの本質的な問題は、継承が静的な型関係を構築する一方で、実行時の振る舞いや関心事の組み合わせに対して過度に硬直的な制約を課す点にあります。
型安全性を確保しようとするあまり、クラス間の結合度が高まり、結果として変更に対する耐性が低下する。
この逆説的な構造こそが、継承の抱える設計上の核心です。

具体的な課題としては、まず親クラと子クラスの密結合が挙げられます。
親クラスの内部実装、特にprotectedメソッドやプロパティの変更は、すべての子クラスに直接的な影響を及ぼします。
親クラスの責務が不明確である場合、子クラスは親の実装詳細に依存した脆弱な構造を持つことになり、リグレッションのリスクが増大します。
単体テストにおいても、子クラスを孤立して検証することが困難になり、親クラスのインスタンス化やモック化が必要となる場面が増えていきます。

次に、単一継承の制約も無視できません。
TypeScriptにおけるクラスは単一の親クラスしか継承できません。
現実のドメインでは、複数の独立した関心事を横断的に持つオブジェクトが頻出します。
例えば、ログ出力可能でありつつシリアライズ可能であり、かつイベント発行も行うような実体を設計する場合、クラス継承ではこれらの振る舞いを直交的方向に組み合わせることができません。
結果として、肥大化した神クラスが生まれるか、無理やり継承階層を深く積み上げるかの二者択一を迫られることになります。

さらに重要なのは、Liskov置換原則の違反リスクです。
型システムはシグネチャレベルの互換性を検査しますが、セマンティクス、すなわち振る舞いの一貫性までは保証しません。
子クラスが親クラスのメソッドをオーバーライドし、前提条件を強めたり後置条件を弱めたりすれば、多態性を利用したクライアントコードは予期せぬバグを生じさせます。
TypeScriptの型チェッカーはこの種の論理的な破綻を検出できないため、設計段階での厳格なレビューが不可欠となります。

以下の表は、継承を用いたコード共通化における主要な特性を整理したものです。

観点 継承による実装 設計上の影響
クラス間の結合度 高い(実装の詳細に依存) 変更の影響範囲が予測困難になる
関心事の分離 階層構造に縛られる 直交する機能の組み合わせが困難
型安全性の担保 コンパイル時に構造を保証 振る舞いの一貫性までは検証されない
テスト容易性 親クラスの状態に依存しやすい 単体テストの独立性が低下する

このように、継承は型システムの上に構築された強力な抽象化メカニズムである一方、使い方を誤れば保守性と拡張性を同時に損なう構造的な脆さを内包しています。
型が通ることと、設計が優れていることは、残念ながら同義ではありません。
では、より柔軟で型安全な共通化の手段は存在しないのでしょうか。
次節以降では、この課題に対する一つの回答としてコンポジションを検討していきます。

継承の限界が型安全性を損なう3つの具体的なケース

継承の限界とLiskov置換原則違反を解説するための技術的な図解イメージ。

前節では、継承がもたらす設計上の課題を概念的に整理しました。
ここではより具体的に、TypeScriptのコードベースで頻出する3つのパターンを検証します。
型システムが静的な構造を保証する一方で、継承の誤用によって実行時の安全性や設計の柔軟性が損なわれるメカニズムを、実際のコードレベルで見ていきましょう。

基底クラスとの密結合が引き起こす変更リスクとテストの困難さ

継承は実装の再利用を促進する一方で、子クラスを親クラスの内部構造に密接に結び付けます。
基底クラスのprotectedメソッドや内部状態に子クラスが依存している場合、親の実装変更は予期せぬ影響を及ぼします。

class Component {
  private isInitialized = false;

  protected checkState(): void {
    if (!this.isInitialized) {
      throw new Error("Not initialized");
    }
  }

  init(): void {
    this.isInitialized = true;
  }
}

class Button extends Component {
  click(): void {
    this.checkState();
    console.log("clicked");
  }
}

この構造では、Component.checkStateのロジックを変更した際、Button.clickの動作が暗黙的に変化する可能性があります。
子クラスを単体テストする際にも、親クラスの初期化状態を考慮したモック構築が必要となり、テストの独立性が低下します。

単一継承の制約と複数の関心事を横断する実装の柔軟性の欠如

TypeScriptのクラスは単一継承に制限されています。
しかし、現実のドメインでは複数の独立した関心事を持つ実体が少なくありません。
たとえば、検証と永続化と通知の3つの能力を持つクラスを設計する場合、継承では直交するこれらの機能を合成することができません。

class Validatable {
  validate(): boolean {
    return true;
  }
}

class Persistable {
  save(): void {
    console.log("saved");
  }
}

class Notifiable {
  notify(): void {
    console.log("notified");
  }
}

// 以下は構文エラーとなる
// class Order extends Validatable, Persistable, Notifiable {}

結果として、肥大化した基底クラスを作成するか、重複した実装を各クラスに散在させるかの二者択一を迫られます。
型の安全性は保たれているかもしれませんが、設計の柔軟性は著しく損なわれます。

Liskov置換原則違反の発生パターンと型チェックでは捕まえきれない落とし穴

型システムはメソッドのシグネチャが一致することを検証しますが、振る舞いのセマンティクスまでは保証しません。
親クラスを子クラスで置き換えた際に、契約が破られるケースです。

class PaymentProcessor {
  process(amount: number): void {
    console.log(`Charged: ${amount}`);
  }
}

class FreeTrialProcessor extends PaymentProcessor {
  process(amount: number): void {
    if (amount > 0) {
      throw new Error("Cannot charge during free trial");
    }
    super.process(amount);
  }
}

function chargeCustomer(processor: PaymentProcessor): void {
  processor.process(100);
}

chargeCustomer(new FreeTrialProcessor()); // 型は通るが実行時に例外が発生する

このコードはTypeScriptの型チェックを通過しますが、FreeTrialProcessorはPaymentProcessorの契約を実質的に破壊しています。
クライアントコードはすべてのプロセッサが課金可能であると仮定しており、結果として予期せぬ実行時エラーが生じます。
型が通ることと、設計が正しいことは等価ではないことを示す典型的な例です。

これら3つのケースは、継承が型安全性の幻想を与えつつも、実際には設計の脆さを隠蔽する要因となりうることを示唆しています。
次節では、この課題に対する構造的な解としてコンポジションを検討します。

コンポジションとは?継承に代わる柔軟なコード共通化手法の基礎

コンポジションの設計思想とhas-a関係を表現したアイキャッチ画像。

継承が「is-a」関係に基づく階層的な抽象化であるのに対し、コンポジションは「has-a」関係に基づく機能の組み合わせを重視する設計アプローチです。
オブジェクトが別のオブジェクトを保有することで振る舞いを委譲し、複数の独立した関心事を直交する方向から合成することが可能になります。
これは、単一継承の制約に縛られない柔軟な構造を実現するための、オブジェクト指向設計における古典的な原則の現代的な表現と言えるでしょう。

コンポジションの本質は、実装の詳細を隠蔽しつつ、必要な機能を実行時に注入できる点にあります。
親クラスの内部状態に子クラスが依存する継承とは異なり、コンポジションではオブジェクトが依存するコンポーネントをインターフェースを通じて受け取ります。
この構造により、クラス間の結合度が低下し、変更の影響範囲が局所化されます。
結果として、テストの際にも実装ではなく契約に対してモックを提供できるため、単体テストの独立性が大きく向上します。

has-a関係に基づく設計思想の本質と関心事の分離

コンポジションの核心的な概念は、オブジェクトが別のオブジェクトを所有する「has-a」関係にあります。
これは、自然な責務の分離を促進し、各クラスが単一の関心事に集中することを可能にします。

interface Engine {
  start(): void;
}

class ElectricMotor implements Engine {
  start(): void {
    console.log("Electric motor started");
  }
}

class Car {
  private engine: Engine;

  constructor(engine: Engine) {
    this.engine = engine;
  }

  drive(): void {
    this.engine.start();
    console.log("Car is moving");
  }
}

この例では、CarはEngineを保有していますが、特定の実装であるElectricMotorに依存しなくても動作します。
ガソリンエンジンや水素エンジンといった別の実装を同じインターフェースで提供すれば、Carクラスの変更なしに動作を切り替えられます。
これが関心事の分離と、依存性の注入によって実現される柔軟性です。

TypeScriptのインターフェスと交叉型による型安全な振る舞いの合成

TypeScriptの型システムは、コンポジションを型安全に実現するための強力な仕組みを提供します。
インターフェースと交叉型を組み合わせることで、複数の振る舞いを型レベルで合成し、コンパイル時に完全な型チェックを行うことができます。

type Loggable = {
  log(message: string): void;
};

type Serializable = {
  serialize(): string;
};

type Notifiable = {
  notify(event: string): void;
};

type ComposedBehavior = Loggable & Serializable & Notifiable;

function createService(): ComposedBehavior {
  return {
    log(message: string): void {
      console.log(message);
    },
    serialize(): string {
      return JSON.stringify(this);
    },
    notify(event: string): void {
      console.log(`Event: ${event}`);
    }
  };
}

ComposedBehavior型は3つの独立した型を交叉型によって合成したものです。
これにより、単一継承の制約を受けることなく、複数の関心事を持つオブジェクトの型を定義できます。
そして重要なのは、この合成は型レベルの操作であり、実行時のオーバーヘッドを伴わない点です。
TypeScriptの設計思想とコンポジションの親和性は、このような型システムの表現力に根ざしています。

コンポジションは単なる実装テクニックではなく、変更に強いソフトウェアを構築するための設計思想です。
次節では、この思想を具体的な実装パターンとして展開していきます。

TypeScriptで実現するコンポジションの実装パターン3選

TypeScriptのミックスインと委譲パターンの実装例を示すコードイメージ。

コンポジションの設計思想をTypeScriptのコードに落とし込む際、単にオブジェクトを埋め込めばよいというものではありません。
型安全性を担保しつつ、柔軟に振る舞いを組み合わせ、かつ実行時のオーバーヘッドを最小化するためには、言語機能とパターンの選択が重要になります。
ここでは、実務で特に有用な3つの実装パターンを検証します。

ミックスインによる振る舞いの型安全な注入と再利用

ミックスインは、クラスに対して追加の振る舞いを動的に合成するパターンです。
TypeScriptでは、クラス式を受け取り拡張したクラスを返す関数として実装することで、型安全に振る舞いを注入できます。

type Constructor<T = {}> = new (...args: any[]) => T;

function Timestampable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    createdAt = new Date();

    getElapsedTime(): number {
      return Date.now() - this.createdAt.getTime();
    }
  };
}

function Activatable<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    isActive = true;

    toggle(): void {
      this.isActive = !this.isActive;
    }
  };
}

class User {
  constructor(public name: string) {}
}

const TimestampedActivatableUser = Activatable(Timestampable(User));

const user = new TimestampedActivatableUser("Alice");
user.toggle();
console.log(user.getElapsedTime());

このパターンの利点は、複数の独立した振る舞いを単一のクラスに型安全に合成できる点にあります。
交叉型と異なり、実行時にも実際にプロパティとメソッドがクラスインスタンスに組み込まれます。
ただし、ミックスイン同士の名前衝突には注意が必要です。

委譲パターンによる責務の分離とクラス間の疎結合化

委譲は、コンポジションの最も基本的な形態です。
オブジェクトが特定の処理を自ら実装するのではなく、保有する別のオブジェクトに処理を委ねることで、責務を明確に分離します。

interface Formatter {
  format(data: string): string;
}

class JsonFormatter implements Formatter {
  format(data: string): string {
    return JSON.stringify({ content: data });
  }
}

class Report {
  private formatter: Formatter;

  constructor(formatter: Formatter) {
    this.formatter = formatter;
  }

  output(data: string): void {
    console.log(this.formatter.format(data));
  }
}

const report = new Report(new JsonFormatter());
report.output("Sales increased by 20%");

Reportクラスは出力形式の詳細を知る必要がありません。
Formatterインターフェースに対してのみ依存することで、XML形式やCSV形式への変更が容易になります。
これは依存性の逆転原則の具体的な表現であり、テスト時にはモックのFormatterを注入することで、Reportの出力メソッドを孤立して検証できます。

ファクトリ関数とオブジェクト合成による柔軟な初期化と型推論

ファクトリ関数は、クラスを介さずに直接オブジェクトを生成し、複数の型を交叉させて返すことで、柔軟な初期化と型推論を実現します。
クラスベースのオーバーヘッドを避けつつ、型安全性を維持したい場面に適しています。

function createTimestampedItem<T extends object>(base: T) {
  return {
    ...base,
    createdAt: new Date(),
    refresh(): void {
      console.log("Item refreshed");
    }
  };
}

const item = createTimestampedItem({ id: 1, label: "Document" });
console.log(item.label);
item.refresh();

このパターンでは、スプレッド構文によって既存のオブジェクトに新たなプロパティとメソッドを合成し、戻り値の型はTypeScriptが自動的に推論します。
型エイリアスを明示的に定義する必要がなく、プロトタイプ的な開発や設定オブジェクトの生成など、構造が頻繁に変化する場面で特に有効です。

これら3つのパターンは、いずれも継承の制約を回避しつつ型安全性を確保する手段です。
次節では、既存の継承ベースのコードをこれらのパターンへと移行する具体的なアプローチを検討します。

継承からコンポジションへのリファクタリング実践ガイド

継承からコンポジションへのリファクタリング手順を示す工程図のアイキャッチ。

理論的な優位性を理解したところで、実際のコードベースにコンポジションを導入するための具体的な手順を検討します。
既存の継承階層を急進的に書き換えることは、回帰バグを生み出すリスクが高く、現場では現実的ではありません。
ここでは、既存の型の互換性を維持しながら、段階的に継承からコンポジションへ移行するための実践的なアプローチを提示します。

既存コードの継承階層を分析し問題点を特定する手順

リファクタリングを開始する前に、まず既存の継承構造がどのような技術的負債を抱えているかを客観的に評価する必要があります。
深い継承階層を持つクラスを可視化し、子クラスが親クラスのprotectedメンバーや内部状態にどの程度依存しているかを特定します。

class DatabaseConnection {
  protected isConnected = false;

  connect(): void {
    this.isConnected = true;
  }
}

class UserRepository extends DatabaseConnection {
  findAll(): string[] {
    if (!this.isConnected) {
      throw new Error("Not connected");
    }
    return ["user1", "user2"];
  }
}

この例では、UserRepositoryが親クラスのisConnectedに直接依存しています。
これは密結合の典型であり、親クラスの内部実装変更が子クラスの振る舞いに影響を及ぼす構造です。
さらに、子クラスが親クラスのメソッドをオーバーライドしている箇所では、Liskov置換原則に違反していないか、前提条件と後置条件の変化を確認する必要があります。
静的解析ツールやコードレビューの観点として、継承階層の深さ、protectedメンバーの参照箇所、オーバーライドの件数を指標にするとよいでしょう。

段階的な移行戦略と型の互換性を維持するためのポイント

一度にすべての継承関係を解体するのではなく、まず親クラスの振る舞いをインターフェースとして抽出し、子クラスに委譲の構造を導入する段階的アプローチが有効です。

interface Connection {
  connect(): void;
}

class DatabaseConnection implements Connection {
  private isConnected = false;

  connect(): void {
    this.isConnected = true;
  }
}

class UserRepository {
  private connection: Connection;

  constructor(connection: Connection) {
    this.connection = connection;
  }

  findAll(): string[] {
    this.connection.connect();
    return ["user1", "user2"];
  }
}

この変更により、UserRepositoryはDatabaseConnectionの内部状態から解放され、代わりにConnectionインターフェースに対して依存するようになります。
テスト時には実装をモック化でき、親クラスの複雑な初期化を考慮する必要がなくなります。

以下の表は、移行を段階的に進めるための指針をまとめたものです。

移行フェーズ 作業内容 型互換性の維持方法
インターフェース抽出 親クラスの公開メソッドをインターフェースとして定義 既存クラスがそのインターフェースを実装することで整合性を担保
委譲構造の導入 子クラスがインターフェースを受け取るようにコンストラクタを変更 デフォルト引数やオーバーロードで既存クライアントコードを段階的に移行
継承関係の削除 extendsを除去し委譲による実装に完全移行 一時的な型アサーションやアダプタパターンで過渡期の整合性を管理

型の互換性を維持する最も重要なポイントは、公開APIのシグネチャを変更しないことです。
内部実装を委譲に置き換えても、クライアントコードが利用するメソッド名や引数、戻り値の型を変えなければ、移行期間中でもコンパイルエラーを最小限に抑えることができます。
リファクタリングの本質は、外部から見た振る舞いを保ちながら内部構造を改善することにあります。
コンポジションへの移行もこの原則に従えば、型安全の下で着実に設計の質を向上させることができるでしょう。

コンポジションが有効な実務シナリオと型設計のベストプラクティス

実務でのコンポジション活用とUIコンポーネント設計のベストプラクティス画像。

コンポジションの理論的な優位性を理解しただけでは、実際の開発現場でどのように適用すればよいかの判断が難しい場合があります。
ここでは、フロントエンドのUI層とドメインモデル層という、性質の異なる2つのシナリオを取り上げ、コンポジションが具体的にどのような価値をもたらすかを検証します。
いずれの場面でも、型システムを活用した関心事の分離と、不変条件の局所化が鍵となります。

UIコンポーネントの横断的関心事を型安全に分離する手法

UIコンポーネントでは、ツールチップ表示ローディング状態無効化といった振る舞いが、ボタン入力欄カードなど複数の要素に横断的に出現します。
継承でこれらを表現しようとすると、コンポーネントツリーに応じた柔軟な組み合わせが困難になります。
コンポジションでは、これらの関心事を型として分離し、必要な機能だけをオブジェクトに合成できます。

type WithTooltip = {
  tooltipText: string;
  showTooltip(): void;
};

type WithLoadingState = {
  isLoading: boolean;
};

function createButton(
  props: { label: string } & WithTooltip & WithLoadingState
) {
  return {
    ...props,
    render(): string {
      const tooltip = this.tooltipText ? ` title="${this.tooltipText}"` : "";
      const disabled = this.isLoading ? " disabled" : "";
      return `<button${tooltip}${disabled}>${this.label}</button>`;
    },
    showTooltip(): void {
      console.log(`Tooltip: ${this.tooltipText}`);
    }
  };
}

const btn = createButton({
  label: "Submit",
  tooltipText: "Send data",
  isLoading: false
});

この構造では、ボタンがツールチップを持つかローディング状態を持つかは、型パラメータの合成によって決まります。
新たな横断的関心事が追加されても、既存のコンポーネントを変更することなく型を拡張できるため、変更に対する閉じた設計を実現します。

ドメインモデルにおける機能の組み合わせと不変条件の保証

ドメイン駆動設計においても、エンティティが複数のライフサイクル状態を持つ場合、コンポジションは有効です。
たとえば、注文は作成後に検証可能であり、発送可能であり、キャンセル可能であるといった複数の能力を持ちます。
これらを継承で表現すると、状態遷移の組み合わせ爆発を招きます。
コンポジションでは、各能力を独立した型として定義し、不変条件をファクトリ関数やメソッド内に局所化できます。

interface Timestamped {
  readonly createdAt: Date;
}

interface Validatable {
  validate(): boolean;
}

interface Cancellable {
  readonly isCancelled: boolean;
  cancel(): void;
}

type Order = {
  orderId: string;
  amount: number;
} & Timestamped & Validatable & Cancellable;

function createOrder(orderId: string, amount: number): Order {
  const createdAt = new Date();
  let isCancelled = false;

  return {
    orderId,
    amount,
    createdAt,
    get isCancelled() {
      return isCancelled;
    },
    validate(): boolean {
      return this.amount > 0 && this.orderId.length > 0;
    },
    cancel(): void {
      if (isCancelled) {
        throw new Error("Order is already cancelled");
      }
      isCancelled = true;
    }
  };
}

createOrderはクロージャを用いてisCancelledの内部状態を保護しつつ、型レベルではOrderとして一貫したインターフェースを提供します。
不変条件である「キャンセル済みの注文は再度キャンセルできない」というルールが、型ではなく実装によって保証されていますが、TypeScriptの型システムは少なくともこのオブジェクトが必要な振る舞いをすべて持つことをコンパイル時に検証します。

以下の表は、2つのシナリオにおけるコンポジションの適用ポイントを整理したものです。

シナリオ 分離する関心事 型設計のポイント 期待される効果
UIコンポーネント ツールチップローディング無効化など 交叉型によるpropsの合成 コンポーネントの再利用性とテスト容易性の向上
ドメインモデル 検証発送キャンセルなどの能力 インターフェースとファクトリ関数の組み合わせ 不変条件の局所化と状態遷移の安全性向上

いずれのケースでも、コンポジションは「すべてを一つのクラスに詰め込む」設計から、「必要な責務だけを組み合わせる」設計へと思考を転換させます。
この転換こそが、TypeScriptの型システムを最大限に活用した堅牢なアーキテクチャの基盤となるでしょう。

継承とコンポジションの使い分け基準:is-aとhas-aの判断フレームワーク

is-aとhas-aの判断フレームワークを示す比較図のアイキャッチ画像。

これまでの節で、継承の構造的な限界とコンポジションによる柔軟な共通化の手法を検証してきました。
しかし、これは継承が常に悪でありコンポジションが常に善であるという単純な二項対立を意味しません。
設計の本質は、対象のドメインが持つ関係性を正確にモデル化することにあります。
ここでは、is-a関係とhas-a関係の見極め方を体系的に整理し、実際のコードベースで適用するための判断フレームワークを提示します。

オブジェクト関係の見極め方と設計指針の策定

is-a関係が成立するかどうかの最も厳格な検証は、Liskov置換原則に照らし合わせたセマンティクスの整合性確認です。
子クラスが親クラスの振る舞いを完全に継承し、契約を破らずに置換可能であるならば、継承は正当化されます。
典型的な例として、組込みのErrorクラスを拡張するカスタムエラーがあります。

class ValidationError extends Error {
  constructor(
    message: string,
    public field: string
  ) {
    super(message);
  }
}

function reportError(error: Error): void {
  console.error(error.message);
}

reportError(new ValidationError("Invalid value", "email"));

ValidationErrorはErrorの一種であり、メッセージの取得やスタックトレースの挙動を変更せずに拡張しています。
これは型の整合性と振る舞いの整合性が両立している、継承の適切な使用例です。

対照的に、has-a関係は機能の所有や委譲を表現します。
HTTPクライアントがロガーを利用する場合、クライアントはロガーの一種ではなく、ロガーの機能を利用する存在です。

interface Logger {
  log(message: string): void;
}

class ConsoleLogger implements Logger {
  log(message: string): void {
    console.log(message);
  }
}

class HttpClient {
  constructor(private logger: Logger) {}

  get(url: string): void {
    this.logger.log(`GET ${url}`);
  }
}

ここでは、HttpClientがLoggerを保有し、その機能を委譲によって利用しています。
ConsoleLoggerをファイルロガーに置き換えても、HttpClientの実装に変更は必要ありません。
これがコンポジションによる関心事の分離の本質です。

以下の表は、2つの関係性の判断基準を整理したものです。

判断基準 継承(is-a) コンポジション(has-a)
関係の性質 分類上の包含関係が成立する 機能の所有または委譲に留まる
変更の影響 親クラスの変更が子クラスに波及する インターフェース境界で影響が遮断される
再利用性 継承階層内に縛られる 複数の文脈で独立して再利用可能
テスト容易性 親クラスの状態を考慮する必要がある モックによる孤立したテストが容易

チーム開発で共有すべきコーディング規約とアーキテクチャ基準の具体例

判断フレームワークを個人の暗黙知に留めると、コードレビューで一貫性のない議論が繰り返されることになります。
チームで設計の質を担保するためには、コーディング規約として明示的な基準を文書化することが有効です。

具体的な規約の例としては、まず継承の使用条件を限定することが挙げられます。
たとえば、「基底クラスのprotectedメンバーへの依存は原則禁止とし、オーバーライドはfinalに相当する設計指針で管理する」といったルールです。
次に、コンポジションをデフォルトの共通化手法と位置づけることです。
新たな機能の重複が発覚した際、まず委譲やミックスインによる実装を検討し、継承はis-a関係が明確に証明された場合にのみ採用するという順序を定めます。

さらに、コードレビューの観点として、以下のチェックリストを共有することで設計の一貫性を保てます。

  • 子クラスは親クラスの振る舞いを完全に置換可能か
  • 親クラスの実装変更が子クラスに予期せぬ影響を及ぼさないか
  • 単一継承の制約が将来の拡張を阻害しないか
  • 委譲による実装で同等の型安全性が得られないか

アーキテクチャ基準としては、横断的関心事はコンポジションで実装し、ドメインの本質的な分類関係のみを継承で表現するという方針を採用するチームも少なくありません。
このような基準をARCHITECTURE.mdやCONTRIBUTING.mdに明文化することで、新規参画者も設計意図を迅速に理解でき、技術的な議論を型の本質に基づいた論理的な議論へと昇華させることができるでしょう。

型安全な設計選択が長期的な生産性と保守性を左右する

型安全な設計選択の重要性をまとめる結論のアイキャッチイメージ。

本記事では、TypeScriptにおける継承の構造的な限界と、コンポジションを用いた型安全なコード共通化の手法を検証してきました。
継承は一見、型システムの上に構築された堅牢な再利用メカニズムとして機能しますが、深い階層ほど密結合と柔軟性の欠如を内包し、結果として変更に弱い設計を生み出すことを確認しました。
型が通ることと設計が優れていることは等価ではなく、型チェッカーが検出できないセマンティクスの破綻こそが、継承の誤用における最も危険な落とし穴です。

一方、コンポジションは「has-a」関係に基づく機能の組み合わせを通じて、単一継承の制約を回避し、複数の関心事を直交する方向から合成することを可能にします。
委譲ミックスインファクトリ関数といった具体的なパターンは、型安全性を損なうことなく、クラス間の結合度を低下させ、テストの独立性を向上させます。
そして何より、TypeScriptのインターフェースと交叉型の表現力は、こうした設計思想をコンパイル時に厳格に検証するための強力な基盤を提供してくれます。

短期的な開発スピードを重視した場合、継承は手軽な共通化手段として魅力的に映るかもしれません。
しかし、ソフトウェアの寿命を通じて発生する変更要求に対応するためには、構造の柔軟性が不可欠です。
コンポジションによる設計は、初期段階でわずかな設計コストを要求するものの、中長期的にはリグレッションのリスクを低減し、機能追加の障壁を取り除くことで、結果として生産性を向上させます。
これは単なるコーディングスタイルの問題ではなく、システムの保守性と進化の可能性を決定づけるアーキテクチャ上の判断です。

以下の表は、本記事で検証した継承とコンポジションの特性を最終的に整理したものです。

観点 継承 コンポジション
関係性 is-aの包含関係 has-aの所有または委譲
柔軟性 単一継承の制約と密結合 複数機能の自由な合成と疎結合
型安全性 構造は保証されるが振る舞いの整合性は保証されない インターフェースと交叉型で構造と契約を両立
長期的影響 変更の波及範囲が拡大しやすい 影響が局所化され保守が容易

設計の選択は、コードの書かれた瞬間ではなく、数ヶ月後の変更要求が来た時に真価を発揮します。
TypeScriptの型システムは、あくまで設計の正しさを補助するツールであり、その上にどのような構造を築くかは開発者の判断に委ねられています。
継承とコンポジションの使い分け基準を意識し、型の流れを設計の指針として活用すること。
それが、持続可能なコードベースを構築するための第一歩となるでしょう。

コメント

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