在JS中工厂模式讲解

工厂模式是一种创建对象的设计模式，其主要目的是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂模式使得对象的创建过程与具体实现分离，从而使代码更具灵活性和可维护性。

工厂模式的概念
工厂模式主要有两种变种：
1、简单工厂模式（Simple Factory Pattern）
2、工厂方法模式（Factory Method Pattern）
3、抽象工厂模式（Abstract Factory Pattern）

1. 简单工厂模式
在简单工厂模式中，工厂类根据传入的参数决定创建哪个具体类的实例。
示例代码：

// 具体产品类
class Car {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`Driving a ${this.model}`);
    }
}

class Truck {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`Driving a ${this.model}`);
    }
}

// 工厂类
class VehicleFactory {
    static createVehicle(type, model) {
        switch(type) {
            case 'car':
                return new Car(model);
            case 'truck':
                return new Truck(model);
            default:
                throw new Error('Unknown vehicle type');
        }
    }
}

// 使用工厂类创建对象
const myCar = VehicleFactory.createVehicle('car', 'Sedan');
myCar.drive();  // 输出: Driving a Sedan

const myTruck = VehicleFactory.createVehicle('truck', 'Pickup');
myTruck.drive();  // 输出: Driving a Pickup

2. 工厂方法模式
工厂方法模式将对象的创建委托给子类，使得工厂类不再直接实例化具体的产品，而是通过子类来实现。
示例代码：

// 具体产品类
class Car {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`Driving a ${this.model}`);
    }
}

class Truck {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`Driving a ${this.model}`);
    }
}

// 抽象工厂类
class VehicleFactory {
    createVehicle() {
        throw new Error('You have to implement the method createVehicle!');
    }
}

// 具体工厂类
class CarFactory extends VehicleFactory {
    createVehicle(model) {
        return new Car(model);
    }
}

class TruckFactory extends VehicleFactory {
    createVehicle(model) {
        return new Truck(model);
    }
}

// 使用具体工厂类创建对象
const carFactory = new CarFactory();
const myCar = carFactory.createVehicle('Sedan');
myCar.drive();  // 输出: Driving a Sedan

const truckFactory = new TruckFactory();
const myTruck = truckFactory.createVehicle('Pickup');
myTruck.drive();  // 输出: Driving a Pickup

3. 抽象工厂模式
抽象工厂模式用于创建一系列相关或相互依赖的对象，而无需指定具体类。
示例代码：

// 产品接口
class Car {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`Driving a ${this.model}`);
    }
}

class Truck {
    constructor(model) {
        this.model = model;
    }

    drive() {
        console.log(`Driving a ${this.model}`);
    }
}

// 抽象工厂接口
class VehicleFactory {
    createCar() {
        throw new Error('You have to implement the method createCar!');
    }

    createTruck() {
        throw new Error('You have to implement the method createTruck!');
    }
}

// 具体工厂类
class ConcreteVehicleFactory extends VehicleFactory {
    createCar(model) {
        return new Car(model);
    }

    createTruck(model) {
        return new Truck(model);
    }
}

// 使用抽象工厂创建对象
const factory = new ConcreteVehicleFactory();
const myCar = factory.createCar('Sedan');
myCar.drive();  // 输出: Driving a Sedan

const myTruck = factory.createTruck('Pickup');
myTruck.drive();  // 输出: Driving a Pickup

工厂模式的优点
1、解耦：客户端代码与具体产品类解耦，客户端不需要知道具体的创建逻辑。
2、扩展性：新增具体产品类时，不需要修改客户端代码，只需增加具体的工厂类即可。
3、灵活性：可以根据需求选择不同的工厂类来创建对象，满足不同的需求。

总结
工厂模式通过将对象的创建过程封装在工厂类中，使得代码结构更清晰、维护更容易。简单工厂模式适合简单的产品创建需求，工厂方法模式适合产品变化频繁的场景，抽象工厂模式适合创建一系列相关对象的场景。根据实际需求选择合适的模式可以提高代码的可维护性和扩展性。