当前位置：首页 > JavaScript

js实现claasFactory

2026-01-31 20:19:44JavaScript

实现 Class Factory 的方法

在 JavaScript 中，可以通过多种方式实现类工厂（Class Factory）的功能。类工厂通常用于动态生成类或构造函数，适合需要根据条件创建不同类结构的场景。

使用构造函数和原型链

通过函数返回一个构造函数，并动态设置其原型链：

js实现claasFactory

function createClass(properties, methods) {
  const Constructor = function() {
    if (properties) {
      for (const prop in properties) {
        this[prop] = properties[prop];
      }
    }
  };

  if (methods) {
    for (const method in methods) {
      Constructor.prototype[method] = methods[method];
    }
  }

  return Constructor;
}

// 使用示例
const Person = createClass(
  { name: 'Default', age: 0 },
  {
    greet() {
      return `Hello, my name is ${this.name}`;
    }
  }
);

const john = new Person();
john.name = 'John';
console.log(john.greet()); // "Hello, my name is John"

使用 ES6 Class 语法

利用 ES6 的 class 语法，通过函数返回类定义：

js实现claasFactory

function createClass(superClass, classDefinition) {
  return class extends (superClass || Object) {
    constructor(...args) {
      super(...args);
      if (classDefinition.initialize) {
        classDefinition.initialize.apply(this, args);
      }
    }

    // 动态添加方法
    ...Object.getOwnPropertyNames(classDefinition)
      .filter(name => name !== 'initialize')
      .reduce((acc, name) => {
        acc[name] = classDefinition[name];
        return acc;
      }, {})
  };
}

// 使用示例
const Animal = createClass(null, {
  initialize(name) {
    this.name = name;
  },
  speak() {
    return `${this.name} makes a noise`;
  }
});

const dog = new Animal('Dog');
console.log(dog.speak()); // "Dog makes a noise"

使用 Proxy 实现动态类

通过 Proxy 对象可以更灵活地控制类的行为：

function createDynamicClass(handler) {
  return new Proxy(class {}, {
    construct(target, args) {
      const instance = new target(...args);
      return new Proxy(instance, handler);
    },
    ...handler
  });
}

// 使用示例
const LoggingClass = createDynamicClass({
  get(target, prop) {
    console.log(`Accessing property: ${prop}`);
    return target[prop];
  }
});

const obj = new LoggingClass();
obj.test = 'value';
console.log(obj.test); // 先打印 "Accessing property: test"，然后输出 "value"

工厂模式与继承结合

实现一个可以继承自指定父类的类工厂：

function classFactory(parentClass = Object, ...mixins) {
  return class extends parentClass {
    constructor(...args) {
      super(...args);
      mixins.forEach(mixin => {
        Object.assign(this, mixin(...args));
      });
    }
  };
}

// 使用示例
const Named = (name) => ({ name });
const Aged = (age) => ({ age });

const Person = classFactory(Object, Named, Aged);
const person = new Person('John', 30);
console.log(person.name, person.age); // "John 30"