TypeScriptでデコレーターとリフレクションを用いてクラスを動的に操作する方法

TypeScriptにおいて、デコレーターとリフレクションを組み合わせることで、クラスの振る舞いやプロパティを動的に操作する強力な手段を得ることができます。これにより、コードの再利用性や柔軟性が向上し、メタプログラミング的な技法を使ってクラスの動作を拡張することが可能です。本記事では、デコレーターとリフレクションの基本的な概念から、クラスに対する動的な操作方法、さらに応用例や注意点について詳しく解説します。

TypeScriptにおけるデコレーターとは

デコレーターは、クラスやそのメンバー（プロパティ、メソッドなど）の定義に対して、追加の処理を付加するための仕組みです。TypeScriptでは、ES7のデコレーター仕様に基づいており、クラス定義の変更やメタデータの追加が可能です。デコレーターは、クラスの柔軟な拡張や、重複したコードの削減に役立ちます。

デコレーターの利点

1. コードの簡潔化：繰り返し発生するロジックを一箇所にまとめ、各クラスやメソッドに対して簡潔に適用できます。
2. 可読性の向上：デコレーターを使うことで、メタ情報をクラスやメソッドに付加し、コードの意図を明確に示すことができます。
3. 動的な拡張：デコレーターにより、クラスの動作を動的に変更でき、プラグインのような柔軟な拡張が可能です。

リフレクションとは何か

リフレクションは、プログラムの実行時にそのプログラムの構造やメタデータにアクセスし、操作する技術です。TypeScriptでは、リフレクションを使用して、クラスやオブジェクトのプロパティ、メソッド、型情報にアクセスすることができ、実行時にこれらを動的に操作できます。通常のプログラミングでは、コンパイル時に固定された構造を操作しますが、リフレクションを使うと柔軟にプログラムの内部状態にアクセスできるようになります。

リフレクションの主な機能

1. メタデータの取得：クラスやプロパティに付与されたデコレーター情報などのメタデータを取得し、実行時に動的に利用できます。
2. クラス構造の解析：リフレクションを使ってクラスのプロパティやメソッドを動的に列挙したり、その型情報を取得できます。
3. 動的なインスタンス操作：リフレクションを使えば、クラスのインスタンスを動的に生成したり、そのプロパティを操作することが可能です。

TypeScriptでのリフレクションの実装例

TypeScriptでリフレクションを使用するには、reflect-metadataパッケージを使うことが一般的です。このパッケージは、メタデータを保存し、それに基づいてリフレクション操作を行うためのAPIを提供します。

import "reflect-metadata";

class MyClass {
  @Reflect.metadata("custom:metadata", "someValue")
  myMethod() {}
}

// メタデータの取得
const metadataValue = Reflect.getMetadata("custom:metadata", MyClass.prototype, "myMethod");
console.log(metadataValue); // "someValue"

このように、リフレクションを使うことで、プログラムの内部構造に柔軟にアクセスし、動的な操作を実現できます。

クラスへのデコレーターの適用方法

TypeScriptでは、クラスにデコレーターを適用することで、そのクラスに新たな機能を追加したり、クラスの振る舞いを動的に変更することができます。デコレーターは、クラス全体、メソッド、プロパティ、アクセサ、またはコンストラクタに対して適用できます。クラスデコレーターは、クラスの定義に関する処理を実行し、必要に応じてそのクラスを拡張したり、変更することができます。

クラスデコレーターの基本構文

クラスデコレーターは、以下のように、クラス定義の上に関数として記述します。デコレーター関数は、クラスを引数として受け取り、必要に応じて変更を加えます。

function MyClassDecorator(constructor: Function) {
  console.log("クラスデコレーターが呼ばれました");
  // クラスに対する処理をここで実行
}

@MyClassDecorator
class MyClass {
  constructor() {
    console.log("MyClassのインスタンスが作成されました");
  }
}

この例では、MyClassDecoratorというデコレーターがMyClassに適用されています。デコレーターは、クラスの定義時に実行され、クラスに対して追加の処理を施すことができます。

クラスデコレーターの実用例

次に、クラスを動的に拡張するデコレーターの例を示します。例えば、クラスのメタデータやログ出力を追加するようなケースです。

function AddTimestamp(constructor: Function) {
  constructor.prototype.timestamp = new Date();
}

@AddTimestamp
class MyClass {
  constructor() {
    console.log("クラスが生成されました");
  }
}

const instance = new MyClass();
console.log(instance.timestamp); // クラスのインスタンスにタイムスタンプが追加される

このデコレーターは、クラスのプロトタイプにtimestampプロパティを追加しています。これにより、クラスのインスタンスが生成される際に、そのインスタンスには動的にタイムスタンプが付与されます。

クラスデコレーターを利用した拡張性

デコレーターを使うことで、クラスの振る舞いやプロパティを動的に変更したり、他のクラスと共有するロジックを統合したりすることが可能です。これにより、コードの再利用性や保守性が向上し、特に大規模なプロジェクトでは効率的な開発が期待できます。

メソッドデコレーターとプロパティデコレーター

TypeScriptでは、メソッドやプロパティにデコレーターを適用することができ、それぞれの動作に対して特定の処理を追加したり、変更することが可能です。メソッドデコレーターとプロパティデコレーターは、クラスデコレーターとは異なり、クラスの一部の機能に対してのみ変更を加えるため、細かい制御が可能です。ここでは、それぞれのデコレーターの使い方と違いについて説明します。

メソッドデコレーター

メソッドデコレーターは、クラスのメソッドに適用され、メソッドの呼び出し前後に処理を挿入したり、メソッド自体を変更することができます。メソッドデコレーター関数は、3つの引数を取ります：対象オブジェクト、メソッド名、メソッドのプロパティディスクリプターです。

function LogMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`${propertyKey}が呼び出されました: ${args}`);
    return originalMethod.apply(this, args);
  };
}

class MyClass {
  @LogMethod
  greet(name: string) {
    return `Hello, ${name}!`;
  }
}

const instance = new MyClass();
instance.greet("TypeScript"); // "greetが呼び出されました: TypeScript"

この例では、greetメソッドにLogMethodデコレーターが適用されています。メソッドが呼び出される際に、その引数がコンソールに表示されるように挙動が変更されています。

メソッドデコレーターの用途

• ログの自動生成: メソッド呼び出しのログを自動的に残すことができます。
• エラーハンドリング: メソッドのエラー処理を一元化できます。
• メソッドの引数や戻り値の検証: メソッドの引数の検証や、戻り値の整合性を確認する処理を追加できます。

プロパティデコレーター

プロパティデコレーターは、クラスのプロパティに適用され、プロパティに関する追加の処理を実行するために使います。プロパティデコレーターは、2つの引数を取ります：対象オブジェクトとプロパティの名前です。

function LogProperty(target: any, propertyKey: string) {
  let value = target[propertyKey];

  const getter = () => {
    console.log(`Getting value of ${propertyKey}: ${value}`);
    return value;
  };

  const setter = (newValue: any) => {
    console.log(`Setting value of ${propertyKey} to: ${newValue}`);
    value = newValue;
  };

  Object.defineProperty(target, propertyKey, {
    get: getter,
    set: setter,
    enumerable: true,
    configurable: true,
  });
}

class MyClass {
  @LogProperty
  name: string;

  constructor(name: string) {
    this.name = name;
  }
}

const instance = new MyClass("TypeScript");
instance.name = "JavaScript"; // "Setting value of name to: JavaScript"
console.log(instance.name);   // "Getting value of name: JavaScript"

この例では、nameプロパティにLogPropertyデコレーターを適用しています。プロパティの値を設定・取得する際に、その操作内容がコンソールに表示されます。

プロパティデコレーターの用途

• プロパティの監視: プロパティの変更やアクセスを監視し、特定の処理を実行できます。
• 値のキャッシュ: プロパティの値をキャッシュし、アクセスするたびに再計算する必要をなくします。
• データの検証: プロパティに設定される値が正しいかどうかを検証できます。

メソッドデコレーターとプロパティデコレーターの違い

• メソッドデコレーターはメソッド自体の動作に影響を与え、呼び出しの前後で処理を追加するのに対し、プロパティデコレーターはプロパティの取得や設定時に処理を追加します。
• メソッドデコレーターは主に、メソッドのロジックに関連する処理を扱い、プロパティデコレーターはプロパティの状態やアクセスに焦点を当てます。

それぞれのデコレーターを適切に使い分けることで、クラスの動作を効率的に制御し、柔軟な設計が可能になります。

動的クラス操作の実例

TypeScriptのデコレーターとリフレクションを組み合わせることで、クラスやそのメンバーを動的に操作できる強力な機能を活用できます。これにより、例えば、メタデータを使ってクラスの動作を変更したり、インスタンス化の際に動的にプロパティを設定することが可能です。ここでは、デコレーターとリフレクションを活用した具体的な動的クラス操作の実例を紹介します。

デコレーターによる動的プロパティ追加

以下の例では、クラスに対して動的にプロパティを追加し、リフレクションを使ってその値を取得する方法を紹介します。デコレーターを使って、クラスインスタンスに必要なプロパティを自動的に設定します。

import "reflect-metadata";

// プロパティを追加するデコレーター
function AddDynamicProperty(target: any, propertyKey: string) {
  Reflect.defineMetadata("dynamicProperty", true, target, propertyKey);
}

class MyClass {
  @AddDynamicProperty
  dynamicField: string;

  constructor() {
    this.dynamicField = "初期値";
  }
}

const instance = new MyClass();

// リフレクションを使用して動的プロパティを確認
const isDynamic = Reflect.getMetadata("dynamicProperty", instance, "dynamicField");
console.log(`dynamicFieldは動的プロパティか？: ${isDynamic}`);  // true
console.log(`プロパティの値: ${instance.dynamicField}`); // "初期値"

この例では、@AddDynamicPropertyデコレーターを使ってdynamicFieldに動的なメタデータを追加しています。リフレクションを使用して、メタデータを基にプロパティが動的に追加されていることを確認しています。

クラスに対するメソッドの動的変更

次に、クラスのメソッドに対して動的な変更を加える実例です。デコレーターを使って、メソッドが呼び出されるたびに追加の処理を動的に挿入できます。

function ModifyMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`${propertyKey}が呼び出されました。引数: ${args}`);
    // ここで追加処理を挿入可能
    const result = originalMethod.apply(this, args);
    console.log(`${propertyKey}が終了しました。結果: ${result}`);
    return result;
  };
}

class MyClass {
  @ModifyMethod
  greet(name: string) {
    return `Hello, ${name}`;
  }
}

const instance = new MyClass();
instance.greet("TypeScript");  // greetが呼び出されました。引数: ["TypeScript"]
                              // greetが終了しました。結果: Hello, TypeScript

この例では、ModifyMethodデコレーターを使用してgreetメソッドの前後にログを出力する動的な処理を追加しています。このように、メソッドの挙動を動的に拡張することが可能です。

実装のポイント

1. デコレーターの役割：デコレーターは、クラスやメンバーに対して柔軟に操作を加える手段を提供します。これにより、動的な振る舞いをプログラム全体に統一して追加できます。
2. リフレクションの活用：リフレクションを使えば、クラスに対するメタデータの読み書きが可能となり、プログラムの実行時に動的な操作を実現できます。TypeScriptでリフレクションを使用するにはreflect-metadataを使うのが一般的です。

このように、デコレーターとリフレクションを組み合わせることで、実行時にクラスやメソッド、プロパティの動的操作が可能となり、柔軟なコード設計ができるようになります。

メタデータを利用した柔軟なクラス操作

TypeScriptにおいて、デコレーターとリフレクションを組み合わせることで、クラスにメタデータを追加し、そのメタデータを基に柔軟な操作を行うことが可能です。メタデータは、クラスやプロパティ、メソッドに関連する追加情報を保存する仕組みで、リフレクションを使って実行時にそのメタデータを読み取り、動的にクラスを操作することができます。

メタデータを使ったクラスの動的操作

reflect-metadataライブラリを使うことで、デコレーターを通じてメタデータをクラスに追加し、それを基に動的に処理を制御できます。ここでは、クラスにメタデータを追加し、そのメタデータを利用してクラスの動作を柔軟に変更する実例を紹介します。

import "reflect-metadata";

// メタデータを追加するデコレーター
function AddMetadata(metadataKey: string, metadataValue: any) {
  return function (target: any, propertyKey?: string) {
    Reflect.defineMetadata(metadataKey, metadataValue, target, propertyKey || undefined);
  };
}

@AddMetadata("role", "admin")
class User {
  @AddMetadata("sensitive", true)
  password: string = "secret";

  constructor(public name: string) {}
}

const user = new User("John Doe");

// メタデータの取得
const classRole = Reflect.getMetadata("role", User);
const isSensitive = Reflect.getMetadata("sensitive", user, "password");

console.log(`User role: ${classRole}`);  // User role: admin
console.log(`Is password sensitive? ${isSensitive}`);  // Is password sensitive? true

この例では、AddMetadataデコレーターを使ってクラスにroleメタデータを追加し、プロパティに対して"sensitive"メタデータを設定しています。リフレクションを使ってこれらのメタデータを動的に取得し、クラスの特定の機能やプロパティがどのように扱われるべきかを制御しています。

メタデータを活用した動的な条件分岐

メタデータを利用することで、クラスやプロパティの状態に応じて異なる処理を実行することができます。例えば、ユーザーのロールに応じて特定の機能を許可・制限する動的な動作を実現できます。

function checkRole(target: any, methodName: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    const role = Reflect.getMetadata("role", target.constructor);
    if (role !== "admin") {
      throw new Error("許可されていない操作です");
    }
    return originalMethod.apply(this, args);
  };
}

class AdminPanel {
  @checkRole
  deleteUser() {
    console.log("ユーザーが削除されました");
  }
}

const adminPanel = new AdminPanel();
Reflect.defineMetadata("role", "user", AdminPanel);

try {
  adminPanel.deleteUser();  // エラー: 許可されていない操作です
} catch (error) {
  console.error(error.message);
}

この例では、checkRoleデコレーターを使用し、メタデータに基づいてメソッドの実行を制御しています。roleメタデータが"admin"でない場合、メソッドの実行が拒否されます。このように、メタデータを活用することで、条件に応じた柔軟な処理が可能になります。

複雑なクラス操作をメタデータで効率化

1. 状態管理：クラスやプロパティに対して状態をメタデータとして追加し、実行時にその状態を確認して処理を変えることができます。
2. 役割ベースのアクセス制御：メタデータを使うことで、ユーザーの役割やアクセス権に基づいた動的なアクセス制御を簡単に実装できます。
3. 自動化されたロジック：メタデータを用いて、条件に応じた処理を自動化し、コード全体の一貫性を保ちながら柔軟にロジックを変更できます。

メタデータを利用したクラス操作は、複雑な条件分岐や状態管理を効率的に実装でき、クラスの機能拡張や管理が非常に容易になります。デコレーターとリフレクションを組み合わせることで、これらのメタデータを実行時に利用し、柔軟なクラス操作が実現できるのです。

デコレーターとリフレクションを使う上での注意点

デコレーターとリフレクションは、TypeScriptにおいて非常に強力で柔軟なツールですが、その使用にはいくつかの注意点があります。特に、実行時に動的な操作を行うため、コードのパフォーマンスやデバッグの難易度、可読性に影響を与える場合があります。ここでは、デコレーターとリフレクションを使う際のベストプラクティスや注意すべきポイントについて解説します。

1. パフォーマンスへの影響

デコレーターやリフレクションは、実行時に追加の処理を行うため、処理が増える分、パフォーマンスに影響を与える可能性があります。特に、メタデータを動的に取得・設定する操作や、メソッドの実行前後にロジックを追加する場合、オーバーヘッドが発生します。

パフォーマンス最適化のポイント

• 必要最小限の使用: デコレーターやリフレクションを適用する範囲を絞り、重要な部分だけに適用します。
• キャッシュの活用: リフレクションによるメタデータの取得結果をキャッシュすることで、同じ情報を何度も取得する処理を避け、パフォーマンスを改善します。

2. デバッグとエラーハンドリング

デコレーターやリフレクションを使うと、コードの実行時に予期せぬエラーが発生する可能性が高くなります。特に、デコレーターが複数の箇所で適用されている場合、エラーの原因を追跡するのが難しくなることがあります。また、リフレクションによって動的にプロパティやメソッドが追加されるため、静的な型チェックが効かないケースもあります。

デバッグのポイント

• 詳細なログの出力: デコレーターやリフレクションを使用する際には、メタデータの取得やメソッドの呼び出しタイミングを詳細にログに残すことで、エラーの原因を特定しやすくします。
• テストの充実: 単体テストや統合テストを充実させ、デコレーターやリフレクションが期待通りに動作していることを確認します。

3. 可読性の低下

デコレーターを多用すると、クラスやメソッドの本来の動作が隠れてしまい、コードの可読性が低下することがあります。デコレーターによって追加された処理は、コードの外からは見えないため、他の開発者がそのコードを理解するのが難しくなることがあります。

可読性向上のための工夫

• コメントを活用: デコレーターがどのような目的で使用されているのか、コードにコメントを付けて説明することで、他の開発者が理解しやすくなります。
• シンプルなデコレーター設計: 複雑なロジックを一つのデコレーターに詰め込まず、責務を分離してシンプルなデコレーターを設計することで、コードの可読性を保ちます。

4. プラグインやフレームワークの依存性

デコレーターやリフレクションは、reflect-metadataのような外部ライブラリに依存することが一般的です。これにより、プロジェクトの依存関係が増え、使用するライブラリがバージョンアップした際に互換性の問題が発生する可能性があります。

依存性管理のポイント

• ライブラリのバージョン管理: 依存するライブラリのバージョンを厳密に管理し、最新の互換性情報を確認することが重要です。
• 標準機能の活用: 可能な限り、TypeScriptやJavaScriptの標準機能で実装できる部分は標準に準拠することで、将来的なメンテナンスを容易にします。

5. セキュリティリスク

リフレクションを使って動的にクラスやプロパティを操作することで、予期しないセキュリティリスクを招く可能性があります。特に、外部からの入力によって動的にクラスを操作する場合、不正な操作が行われるリスクがあります。

セキュリティ対策

• 入力の検証: 外部から渡されるデータや入力を厳密に検証し、信頼できないデータによってクラスが動的に操作されることを防ぎます。
• 最小限の露出: リフレクションで操作可能なクラスやメソッドの範囲を最小限に留め、セキュリティリスクを軽減します。

デコレーターやリフレクションは便利な機能ですが、その強力さゆえに慎重な使用が求められます。これらの注意点を意識することで、保守性やセキュリティを保ちながら、効果的にデコレーターとリフレクションを活用することができます。

実装のパフォーマンスへの影響

デコレーターとリフレクションは、TypeScriptの動的な機能拡張やクラス操作を可能にする非常に便利なツールですが、パフォーマンスに影響を与える場合があります。特に、実行時にメタデータを取得したり、クラスのプロパティやメソッドに対して動的な操作を行う際、通常のコードに比べて余分な処理が追加されるため、注意が必要です。

デコレーターによるパフォーマンスへの影響

デコレーターは、クラスの定義時に実行されるため、実装時にコードが追加され、特定のロジックが自動的に挿入されます。これにより、次のようなパフォーマンスへの影響が考えられます。

1. 初期化時の負荷

デコレーターは、クラスやメソッド、プロパティが定義されたときに実行されるため、クラスの初期化時に余分な処理が入ります。これが、複雑なデコレーション処理が施されたクラスが多くなると、初期化時の負荷が大きくなる可能性があります。

function HeavyInit(target: Function) {
  console.time("Initialization");
  // 複雑な処理のシミュレーション
  for (let i = 0; i < 1000000; i++) {}
  console.timeEnd("Initialization");
}

@HeavyInit
class MyClass {
  constructor() {
    console.log("MyClassのインスタンスが作成されました");
  }
}

new MyClass(); // クラスの初期化時に時間のかかる処理が実行される

この例では、デコレーターがクラスの初期化時に余分な処理を挿入しており、実行時にパフォーマンスが低下する可能性があります。

2. 実行時のオーバーヘッド

メソッドデコレーターは、メソッドが呼び出されるたびに追加の処理が発生するため、頻繁に使用されるメソッドに適用されると、パフォーマンスに悪影響を及ぼすことがあります。特に、大量のデータを処理するメソッドやリアルタイム性が求められる処理では、メソッドデコレーターのオーバーヘッドが問題になることがあります。

function LogExecutionTime(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.time(`${propertyKey} execution`);
    const result = originalMethod.apply(this, args);
    console.timeEnd(`${propertyKey} execution`);
    return result;
  };
}

class Calculator {
  @LogExecutionTime
  heavyComputation() {
    for (let i = 0; i < 1000000; i++) {} // 重い計算処理
    return "Done";
  }
}

const calc = new Calculator();
calc.heavyComputation(); // 処理時間のログが記録されるが、オーバーヘッドが発生

この例では、メソッドにデコレーターを適用することで実行時間の計測が行われていますが、デコレーターの処理自体がオーバーヘッドを引き起こしています。

リフレクションによるパフォーマンスへの影響

リフレクションは、実行時にクラスやオブジェクトの構造にアクセスして操作するため、通常の静的なコードに比べて処理が遅くなる可能性があります。特に、頻繁にリフレクションを使ってプロパティやメソッドにアクセスする場合、パフォーマンスが低下することがあります。

1. メタデータの読み書きによる遅延

リフレクションを使用してメタデータを読み書きする操作は、通常のコードに比べて余分な処理が追加されます。大量のメタデータ操作が必要な場合、パフォーマンスが問題になることがあります。

import "reflect-metadata";

class MyClass {
  @Reflect.metadata("role", "admin")
  greet() {
    console.log("Hello, Admin!");
  }
}

const instance = new MyClass();
console.time("Reflect metadata access");
const role = Reflect.getMetadata("role", instance, "greet");
console.timeEnd("Reflect metadata access"); // メタデータの取得に時間がかかる可能性がある
console.log(role); // "admin"

この例では、リフレクションを使用してメタデータを取得していますが、これが頻繁に行われると処理が遅くなる可能性があります。

パフォーマンスを改善する方法

デコレーターやリフレクションのパフォーマンスへの影響を最小限に抑えるためには、いくつかの対策を取ることが重要です。

1. デコレーターの適用範囲を絞る

デコレーターは、必要な箇所にのみ適用することで、オーバーヘッドを減らすことができます。特に、頻繁に呼び出されるメソッドやプロパティにデコレーターを適用する際には、その影響を十分に考慮する必要があります。

2. リフレクションのキャッシュを活用する

リフレクションで取得したメタデータやプロパティ情報をキャッシュし、繰り返し取得する処理を避けることで、パフォーマンスを向上させることができます。

3. 事前計算や静的解析を活用する

可能であれば、コンパイル時に必要なデータやメタデータを生成し、実行時の計算やリフレクションを減らす方法を検討することで、パフォーマンスの改善が期待できます。

デコレーターとリフレクションは非常に強力なツールですが、適切に使用しないとパフォーマンスに悪影響を与える可能性があります。これらの注意点を考慮し、効率的な実装を心がけることが重要です。

実用的な応用例：クラスのログ管理

TypeScriptのデコレーターとリフレクションを活用すると、クラスやメソッドの実行状況を自動的に監視し、ログを生成するシステムを簡単に実装することができます。特に、デバッグやモニタリングに役立つログ管理システムを構築する際、デコレーターを使うことで、各メソッドの呼び出しや実行時間などを記録する処理を一元化し、コード全体の管理が容易になります。

ここでは、クラスのメソッドの実行を監視して、実行ログを自動的に生成する実用例を紹介します。

メソッドログデコレーターの実装

次の例では、LogMethodデコレーターを使用して、メソッドが呼び出された際に、その実行開始と終了のログを自動的に記録します。これにより、どのメソッドがいつ実行され、どれだけの時間がかかったのかを把握できるようになります。

function LogMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log(`メソッド ${propertyKey} が呼び出されました。引数: ${JSON.stringify(args)}`);
    const start = Date.now();

    const result = originalMethod.apply(this, args);

    const end = Date.now();
    console.log(`メソッド ${propertyKey} が終了しました。実行時間: ${end - start}ms`);

    return result;
  };
}

class UserService {
  @LogMethod
  getUserDetails(userId: number) {
    // ユーザー情報を取得する処理（ここではシミュレーション）
    for (let i = 0; i < 100000000; i++) {} // 重い処理をシミュレーション
    return { id: userId, name: "John Doe" };
  }

  @LogMethod
  updateUserDetails(userId: number, name: string) {
    // ユーザー情報を更新する処理（ここではシミュレーション）
    return `ユーザー ${userId} の名前を ${name} に更新しました`;
  }
}

const userService = new UserService();
userService.getUserDetails(1);
userService.updateUserDetails(1, "Jane Doe");

このコードでは、LogMethodデコレーターをgetUserDetailsとupdateUserDetailsメソッドに適用しています。メソッドが呼び出されるたびに、実行開始と終了時にログが自動的に出力され、さらに実行時間も計測されています。

実行結果の例：

メソッド getUserDetails が呼び出されました。引数: [1]
メソッド getUserDetails が終了しました。実行時間: 50ms
メソッド updateUserDetails が呼び出されました。引数: [1, "Jane Doe"]
メソッド updateUserDetails が終了しました。実行時間: 10ms

プロパティ変更のログ記録

デコレーターはメソッドだけでなく、プロパティに対しても適用できます。プロパティの変更を監視し、その変更をログに残す仕組みも簡単に実装できます。

function LogProperty(target: any, propertyKey: string) {
  let value = target[propertyKey];

  const getter = () => {
    console.log(`プロパティ ${propertyKey} が読み取られました: ${value}`);
    return value;
  };

  const setter = (newValue: any) => {
    console.log(`プロパティ ${propertyKey} が更新されました。新しい値: ${newValue}`);
    value = newValue;
  };

  Object.defineProperty(target, propertyKey, {
    get: getter,
    set: setter,
    enumerable: true,
    configurable: true,
  });
}

class User {
  @LogProperty
  public name: string;

  constructor(name: string) {
    this.name = name;
  }
}

const user = new User("John Doe");
user.name = "Jane Doe";  // プロパティの変更がログに記録される
console.log(user.name);  // プロパティの取得もログに記録される

この例では、プロパティにLogPropertyデコレーターを適用し、nameプロパティが読み取られたり変更された際に、その操作がログに記録されます。

実行結果の例：

プロパティ name が更新されました。新しい値: Jane Doe
プロパティ name が読み取られました: Jane Doe

ログデコレーターの応用例

• パフォーマンスモニタリング：各メソッドの実行時間を計測し、処理が遅い箇所を特定するためのモニタリングツールとして活用できます。
• エラーハンドリング：デコレーターを用いて、メソッド実行時に発生したエラーも自動的にキャッチし、ログに残すことができます。
• アクセス制御の監視：重要なプロパティへのアクセスを監視し、不正なアクセスが発生した場合にアラートを発生させることも可能です。

まとめ

デコレーターとリフレクションを活用したクラスのログ管理は、メソッドやプロパティの呼び出し状況を自動的に記録し、コードベース全体のモニタリングやデバッグを強化するのに非常に有効です。シンプルなコードでログ出力を一元管理できるため、コードの可読性や保守性も向上します。

応用演習：カスタムデコレーターの作成

デコレーターの基本的な使い方を理解したところで、ここではカスタムデコレーターを作成し、実際にクラスやメソッドの動作を拡張する演習を行います。この演習を通じて、TypeScriptのデコレーターをさらに深く理解し、実践的に活用する力を養います。

演習1: メソッドの実行結果をキャッシュするデコレーター

この演習では、メソッドの実行結果をキャッシュし、同じ引数で再度呼び出された場合、再計算せずにキャッシュから結果を返すデコレーターを作成します。

ステップ1: キャッシュデコレーターの作成

まずは、キャッシュ機能を提供するデコレーターを作成します。

function CacheResult(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  const cache = new Map();

  descriptor.value = function (...args: any[]) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log(`キャッシュから結果を取得しました: ${key}`);
      return cache.get(key);
    }
    const result = originalMethod.apply(this, args);
    cache.set(key, result);
    console.log(`計算を実行し、結果をキャッシュしました: ${key}`);
    return result;
  };
}

このデコレーターは、引数をキーとして結果をキャッシュします。すでにキャッシュが存在する場合、計算を行わずにキャッシュから結果を返します。

ステップ2: キャッシュデコレーターを適用

次に、このデコレーターをクラスのメソッドに適用して、重い計算処理に対してキャッシュ機能を付加します。

class Calculator {
  @CacheResult
  heavyComputation(x: number, y: number) {
    console.log(`計算中...`);
    for (let i = 0; i < 100000000; i++) {} // 重い計算処理をシミュレーション
    return x + y;
  }
}

const calc = new Calculator();
console.log(calc.heavyComputation(5, 3));  // 計算を実行
console.log(calc.heavyComputation(5, 3));  // キャッシュから結果を取得

実行結果の例:

計算中...
計算を実行し、結果をキャッシュしました: [5,3]
キャッシュから結果を取得しました: [5,3]

この例では、heavyComputationメソッドが最初に呼び出された際に結果がキャッシュされ、2回目以降はキャッシュから結果が返されます。これにより、重い計算処理の再実行を避け、パフォーマンスを最適化します。

演習2: 引数の型をチェックするデコレーター

次に、メソッドに渡される引数の型をチェックし、正しい型でない場合にエラーを投げるデコレーターを作成します。

ステップ1: 型チェックデコレーターの作成

このデコレーターは、メソッドに渡された引数の型をチェックします。

function ValidateTypes(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    args.forEach(arg => {
      if (typeof arg !== "number") {
        throw new Error(`引数 ${arg} は数値型ではありません`);
      }
    });
    return originalMethod.apply(this, args);
  };
}

ステップ2: 型チェックデコレーターを適用

このデコレーターをメソッドに適用して、引数が数値型であるかを確認します。

class MathOperations {
  @ValidateTypes
  add(a: number, b: number) {
    return a + b;
  }
}

const math = new MathOperations();
console.log(math.add(10, 5));   // 正常に実行
console.log(math.add(10, "5")); // エラーが発生

実行結果の例:

15
エラー: 引数 5 は数値型ではありません

このデコレーターを使用することで、引数が期待された型であることを保証し、不正な値が渡された際にはエラーを通知できます。

演習3: ログイン認証のシミュレーション

最後に、ログインユーザーの権限に基づいてメソッドの実行を制限するデコレーターを作成します。これにより、特定のユーザーのみが操作できるメソッドを作ることができます。

ステップ1: 認証デコレーターの作成

このデコレーターは、ユーザーが管理者であるかどうかをチェックします。

function AdminOnly(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    if (!this.isAdmin) {
      throw new Error(`この操作は管理者のみが実行可能です`);
    }
    return originalMethod.apply(this, args);
  };
}

ステップ2: 認証デコレーターを適用

このデコレーターを、管理者のみが実行できるメソッドに適用します。

class AdminService {
  isAdmin: boolean;

  constructor(isAdmin: boolean) {
    this.isAdmin = isAdmin;
  }

  @AdminOnly
  deleteUser(userId: number) {
    return `ユーザー ${userId} を削除しました`;
  }
}

const admin = new AdminService(true);
console.log(admin.deleteUser(1));  // 正常に実行

const guest = new AdminService(false);
console.log(guest.deleteUser(1));  // エラー: この操作は管理者のみが実行可能です

実行結果の例:

ユーザー 1 を削除しました
エラー: この操作は管理者のみが実行可能です

まとめ

これらの演習を通じて、デコレーターの柔軟性と応用力を実感できたと思います。TypeScriptのデコレーターを用いることで、ロジックを抽象化し、コードの保守性や拡張性を高めることが可能です。さまざまなシナリオでデコレーターを活用し、さらに高度なプログラミング技術を習得しましょう。

まとめ

本記事では、TypeScriptのデコレーターとリフレクションを使用して、クラスを動的に操作する方法について詳しく解説しました。デコレーターを利用して、メソッドの実行ログを自動化したり、引数の型をチェックしたり、実行結果をキャッシュするなど、さまざまな機能を動的に追加できることを学びました。また、リフレクションを活用して、クラスのメタデータを取得し、柔軟に動作を制御することも可能です。デコレーターはコードの再利用性と拡張性を高め、効率的な開発を支える強力なツールです。