TypeScript 交差タイプ

交差タイプ(Intersection Types)は複数のタイプを1つの新しいタイプに結合し、新しいタイプにはすべてのメンバーのタイプが含まれます。

これはオブジェクト指向における多重継承に似ており、1つのタイプが複数のタイプの特性を持つことを可能にします。


SVG 図:交差タイプ 背景 タイトル 交差タイプの動作原理 タイプ A タイプ A (Person) name: string age: number プラス記号 & タイプ B タイプ B (Worker) company: string salary: number 矢印 結合 交差タイプ A & B (Employee) name: string age: number company: string salary: number 下半分:使用シーン 交差タイプの使用シーン シーン1 タイプの組み合わせ 複数のタイプの特性を結合 シーン2 Mixin パターン 複数のクラスの機能を組み合わせる シーン3 インターフェース継承の代替 より簡潔なタイプの組み合わせ 矢印マーク

なぜ交差タイプが必要なのか

開発では、1つのタイプが複数のタイプの特性を持つ必要があることがよくあります。

例えば、従業員は人間(Person)でもあり、労働者(Worker)でもあるため、両方の属性を同時に持つ必要があります。

交差タイプを使用すると、複数のタイプを1つに結合して、このようなニーズを満たすことができます。

概念の説明:交差タイプは&記号で複数のタイプを接続し、新しいタイプがすべてのタイプのメンバーを含むことを示します。これは多重継承の概念に似ています。


基本構文

使用&記号で複数のタイプを組み合わせます。

例

// 人タイプを定義
// 名前と年齢を含む
interface Person {
    name: string;
    age: number;
}

// 労働者タイプを定義
// 会社名と給与を含む
interface Worker {
    company: string;
    salary: number;
}

// 交差タイプを使用して2つのインターフェースを結合
// Employee タイプは Person と Worker のすべての属性を同時に持つ
type Employee = Person & Worker;

// 両方のタイプの特性を同時に持つオブジェクトを作成
var employee: Employee = {
    name: "Alice",
    age: 25,
    company: "Google",
    salary: 100000
};

console.log("従業員: " + JSON.stringify(employee));

実行結果:

员工: {"name":"Alice","age":25,"company":"Google","salary":100000}

説明:交差タイプA & Bは、新しいタイプが A と B のすべての属性を同時に持ち、どれ一つ欠けてもいけないことを意味します。


交差タイプとインターフェース継承

交差タイプはインターフェースの多重継承の代わりになります。

例

// タイプ A を定義
interface A {
    a: string;
}

// タイプ B を定義
interface B {
    b: number;
}

// インターフェースを使用して複数のインターフェースを継承
// extends を使用して複数のインターフェースを継承する必要がある
interface AB extends A, B {
    c: boolean;
}

// 交差タイプを使用(より簡潔)
// & 記号を直接使用してタイプを組み合わせる
type ABType = A & B & { c: boolean };

// どちらの方法でもすべての属性を含むタイプを作成できる
var obj: ABType = { a: "hello", b: 42, c: true };
console.log("オブジェクト: " + JSON.stringify(obj));

実行結果:

对象: {"a":"hello","b":42,"c":true}

比較:交差タイプはインターフェース継承よりも簡潔です。特に、複数のタイプを継承し、追加の属性を追加する必要がある場合に有効です。


タイプの混合(Mixin パターン)

交差タイプを使用して Mixin パターンを実装すると、クラスの機能を動的に組み合わせることができます。

例

// コンストラクタタイプを定義
// 任意のパラメータを受け取り、オブジェクトを返す
type Constructor = new (...args: any[]) => {};

// Mixin: タイムスタンプ機能を追加
// Base を拡張した新しいクラスを返す
function Timestamped<T extends Constructor>(Base: T) {
    return class extends Base {
        timestamp = Date.now();
    };
}

// Mixin: シリアライズ機能を追加
// Base を拡張した、serialize メソッドを含む新しいクラスを返す
function Serializable<T extends Constructor>(Base: T) {
    return class extends Base {
        serialize() {
            return JSON.stringify(this);
        }
    };
}

// 基本ユーザークラス
class User {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}

// Mixin を組み合わせる
// タイムスタンプ機能を持つユーザークラスを作成
var TimestampedUser = Timestamped(User);
// シリアライズ機能を持つユーザークラスを作成
var SerializableUser = Serializable(User);
// 2つの Mixin を組み合わせる
var FullUser = Serializable(Timestamped(User));

// インスタンスを作成してテスト
var user = new FullUser("Alice");
console.log("タイムスタンプ: " + user.timestamp);
console.log("シリアライズ: " + user.serialize());

実行結果:

时间戳: 17134...
序列化: {"name":"Alice","timestamp":17134...}

Mixin パターン:これは強力なパターンであり、元のクラスを変更せずに新しい機能を追加できます。


交差タイプとユニオンタイプ

交差タイプとユニオンタイプを組み合わせる際は、優先順位に特に注意する必要があります。

例

// ユニオンタイプ: 文字列または数値
type StringOrNumber = string | number;

// 交差タイプ: 互換性のないタイプの交差
// string & number = never(文字列と数値の両方であるタイプは存在しない)
type Both = string & number;

// 3つのタイプを定義
type A = { a: string };
type B = { b: number };
type C = { c: boolean };

// ユニオンタイプと交差タイプを組み合わせる
// (A | B) & C はユニオンタイプの各ブランチを C と交差させる
type Combined = (A | B) & C;

// 実際の結果: { a: string; c: boolean } | { b: number; c: boolean }
// つまり、A + C または B + C のいずれか
var obj: Combined = { a: "hello", c: true };
console.log("組み合わせ: " + JSON.stringify(obj));

実行結果:

组合: {"a":"hello","c":true}

重要:互換性のないタイプを交差させるとneverタイプになります。例えばstring & numberは無効です。


実用的な交差タイプ

交差タイプは、ユーティリティタイプを作成してタイプの変換を実現するためによく使用されます。

例

// マップタイプ: すべての属性をオプションにする
// T のすべての属性を走査し、? を追加してオプションにする
type Partial<T> = { [P in keyof T]?: T[P] };

// マップタイプ: すべての属性を必須にする
// T のすべての属性を走査し、? を削除して必須にする
type Required<T> = { [P in keyof T]-?: T[P] };

// マップタイプ: すべての属性を読み取り専用にする
// T のすべての属性を走査し、readonly を追加
type Readonly<T> = { readonly [P in keyof T]: T[P] };

// 設定インターフェースを定義
interface Config {
    host: string;
    port: number;
}

// ユーティリティタイプを使用
var partialConfig: Partial<Config> = { host: "localhost" };
var requiredConfig: Required<Config> = { host: "localhost", port: 8080 };
var readonlyConfig: Readonly<Config> = { host: "localhost", port: 8080 };

console.log("部分: " + JSON.stringify(partialConfig));
console.log("必須: " + JSON.stringify(requiredConfig));
console.log("読み取り専用: " + JSON.stringify(readonlyConfig));

実行結果:

部分: {"host":"localhost"}
必填: {"host":"localhost","port":8080}
只读: {"host":"localhost","port":8080}

ユーティリティタイプ:TypeScript の標準ライブラリには、Partial、Required、Readonly など、交差タイプとマップタイプに基づく多くのユーティリティタイプが用意されています。


注意事項

  • 互換性のないタイプ:互換性のないタイプを交差させると never になる
  • 優先順位:ユニオンタイプの優先順位は交差タイプよりも高い
  • メソッドの競合:2つのタイプに同じ名前のメソッドがある場合は、競合を手動で処理する必要があります

ベストプラクティス:交差タイプは複数のインターフェースやタイプを組み合わせるのに適しています。多重継承が必要な場合は、インターフェース継承ではなく交差タイプを優先して使用してください。


まとめ

交差タイプは、TypeScript における強力なタイプ組み合わせツールです。

  • 構文:使用&記号で複数のタイプを接続する
  • 結合:新しいタイプはすべてのタイプのメンバーを含む
  • Mixin:クラスの機能を組み合わせるために使用できます
  • never:互換性のないタイプの交差は never タイプになります

推奨:交差タイプを適切に使用すると柔軟なタイプの組み合わせを作成できますが、不要なタイプの交差による never タイプを避けるように注意してください。


その他の拡張