TypeScript 元编程：反射与代码生成

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

  descriptor.value = function (...args: any[]) {
    console.log(`Calling method ${propertyKey} with arguments: ${JSON.stringify(args)}`);
    const result = originalMethod.apply(this, args);
    console.log(`Method ${propertyKey} returned: ${result}`);
    return result;
  };

  return descriptor;
}

class MyClass {
  @logMethod
  add(x: number, y: number): number {
    return x + y;
  }
}

const myInstance = new MyClass();
myInstance.add(5, 3);

            

              
                Copy
              
            
          

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

    descriptor.value = function (...args: any[]) {
      console.log(`${prefix} - Calling method ${propertyKey} with arguments: ${JSON.stringify(args)}`);
      const result = originalMethod.apply(this, args);
      console.log(`${prefix} - Method ${propertyKey} returned: ${result}`);
      return result;
    };

    return descriptor;
  };
}

class MyClass {
  @logMethodWithPrefix("DEBUG")
  add(x: number, y: number): number {
    return x + y;
  }
}

const myInstance = new MyClass();
myInstance.add(5, 3);

            

              
                Copy
              
            
          

            
npm install reflect-metadata --save

            

              
                Copy
              
            
          

            
{
  "compilerOptions": {
    "emitDecoratorMetadata": true
  }
}

            

              
                Copy
              
            
          

            
import 'reflect-metadata';

const requiredMetadataKey = Symbol("required");

function required(target: Object, propertyKey: string | symbol, parameterIndex: number) {
  let existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || [];
  existingRequiredParameters.push(parameterIndex);
  Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey);
}

function validate(target: any, propertyName: string, descriptor: TypedPropertyDescriptor) {
  let method = descriptor.value!;

  descriptor.value = function () {
    let requiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyName);
    if (requiredParameters) {
      for (let parameterIndex of requiredParameters) {
        if (arguments.length <= parameterIndex || arguments[parameterIndex] === undefined) {
          throw new Error("Missing required argument.");
        }
      }
    }
    return method.apply(this, arguments);
  };
}

class MyClass {
  myMethod(@required param1: string, param2: number) {
    console.log(param1, param2);
  }
}

            

              
                Copy
              
            
          

            
import * as ts from "typescript";
import * as fs from "fs";

function generateDTO(sourceFile: ts.SourceFile, className: string): string | undefined {
  let interfaceName = className + "DTO";
  let properties: string[] = [];

  function visit(node: ts.Node) {
    if (ts.isClassDeclaration(node) && node.name?.text === className) {
      node.members.forEach(member => {
        if (ts.isPropertyDeclaration(member) && member.name) {
          let propertyName = member.name.getText(sourceFile);
          let typeName = "any"; // Default type

          if (member.type) {
            typeName = member.type.getText(sourceFile);
          }

          properties.push(`  ${propertyName}: ${typeName};`);
        }
      });
    }
  }

  ts.visitNode(sourceFile, visit);

  if (properties.length > 0) {
    return `interface ${interfaceName} {\\n${properties.join("\\n")}\\n}`;
  }

  return undefined;
}

// Example Usage
const fileName = "./src/my_class.ts"; // Replace with your file path
const classNameToGenerateDTO = "MyClass";

fs.readFile(fileName, (err, buffer) => {
  if (err) {
    console.error("Error reading file:", err);
    return;
  }

  const sourceCode = buffer.toString();

  const sourceFile = ts.createSourceFile(
    fileName,
    sourceCode,
    ts.ScriptTarget.ES2015,
    true
  );

  const dtoInterface = generateDTO(sourceFile, classNameToGenerateDTO);

  if (dtoInterface) {
    console.log(dtoInterface);
  } else {
    console.log(`Class ${classNameToGenerateDTO} not found or no properties to generate DTO from.`);
  }
});

            

              
                Copy
              
            
          

            
class MyClass {
  name: string;
  age: number;
  isActive: boolean;
}

            

              
                Copy
              
            
          

            
interface MyClassDTO {
  name: string;
  age: number;
  isActive: boolean;
}

            

              
                Copy