TypeScript:如何通过类转换器序列化和反序列化具有不同名称的对象

// 定义一个类装饰器
function SerializeClass(target: any) {
  // 保存原始类的构造函数
  const originalConstructor = target;

  // 定义一个新的构造函数
  const newConstructor: any = function (...args: any[]) {
    // 创建原始类的实例
    const instance = new originalConstructor(...args);

    // 序列化对象
    instance.serialize = function () {
      const serializedObj: any = {};

      // 遍历对象的属性
      for (const key in this) {
        if (this.hasOwnProperty(key)) {
          // 将属性名转换为大写形式
          const upperCaseKey = key.toUpperCase();
          // 将属性值赋给新的属性名
          serializedObj[upperCaseKey] = this[key];
        }
      }

      // 返回序列化后的对象
      return serializedObj;
    };

    // 反序列化对象
    instance.deserialize = function (serializedObj: any) {
      // 遍历序列化后的对象
      for (const key in serializedObj) {
        if (serializedObj.hasOwnProperty(key)) {
          // 将属性名转换为小写形式
          const lowerCaseKey = key.toLowerCase();
          // 将属性值赋给新的属性名
          this[lowerCaseKey] = serializedObj[key];
        }
      }
    };

    // 返回新的构造函数
    return instance;
  };

  // 复制原始类的原型属性
  newConstructor.prototype = originalConstructor.prototype;

  // 返回新的构造函数
  return newConstructor;
}

// 定义一个具有不同名称的对象
@SerializeClass
class Person {
  constructor(public name: string, public age: number) {}
}

// 创建对象实例
const person = new Person("John", 25);

// 序列化对象
const serializedObj = person.serialize();
console.log(serializedObj); // { NAME: 'John', AGE: 25 }

// 反序列化对象
const deserializedPerson = new Person();
deserializedPerson.deserialize(serializedObj);
console.log(deserializedPerson); // Person { name: 'John', age: 25 }