工厂模式是一种常见的设计模式，它可以帮助我们简化对象的创建过程，提高代码的可维护性和可扩展性。在 TypeScript 中，使用工厂模式可以更好地利用类型系统的优势，提高代码的类型安全性和可读性。本文将介绍 TypeScript 中工厂模式的写法，包括简单工厂、工厂方法和抽象工厂三种类型。
简单工厂
简单工厂是最基本的工厂模式，它通过一个工厂类来创建对象，客户端只需要提供参数即可获得所需的对象。在 TypeScript 中，我们可以使用接口来定义对象的类型，使用类来实现工厂类和具体对象类。
下面是一个简单工厂的示例代码：
// javascriptcn.com 代码示例
interface Product {
name: string;
}
class ConcreteProductA implements Product {
name = 'ProductA';
}
class ConcreteProductB implements Product {
name = 'ProductB';
}
class SimpleFactory {
createProduct(type: 'A' | 'B'): Product {
switch (type) {
case 'A':
return new ConcreteProductA();
case 'B':
return new ConcreteProductB();
default:
throw new Error(`Invalid product type: ${type}`);
}
}
}
const factory = new SimpleFactory();
const productA = factory.createProduct('A');
const productB = factory.createProduct('B');
console.log(productA.name); // Output: ProductA
console.log(productB.name); // Output: ProductB在上面的代码中，我们定义了一个 Product 接口，它包含了一个 name 属性，用来表示产品的名称。然后我们分别定义了两个具体产品类 ConcreteProductA 和 ConcreteProductB，它们都实现了 Product 接口，并分别设置了自己的名称。
接着我们定义了一个 SimpleFactory 类，它包含了一个 createProduct 方法，用来根据传入的参数创建不同的产品对象。在方法中，我们使用 switch 语句来判断产品类型，并返回对应的产品对象。如果传入的类型不合法，我们则抛出一个错误。
最后，我们创建了一个工厂对象 factory，并使用它来创建了两个产品对象 productA 和 productB。通过打印它们的名称，我们可以看到它们确实是我们所期望的产品对象。
工厂方法
工厂方法是简单工厂的升级版，它将工厂类抽象出来，使得每个具体产品类都可以有自己的工厂类。在 TypeScript 中，我们可以使用抽象类和接口来实现工厂方法模式。
下面是一个工厂方法的示例代码：
// javascriptcn.com 代码示例
interface Product {
name: string;
}
abstract class Factory {
abstract createProduct(): Product;
}
class ConcreteFactoryA extends Factory {
createProduct(): Product {
return new ConcreteProductA();
}
}
class ConcreteFactoryB extends Factory {
createProduct(): Product {
return new ConcreteProductB();
}
}
class ConcreteProductA implements Product {
name = 'ProductA';
}
class ConcreteProductB implements Product {
name = 'ProductB';
}
const factoryA = new ConcreteFactoryA();
const factoryB = new ConcreteFactoryB();
const productA = factoryA.createProduct();
const productB = factoryB.createProduct();
console.log(productA.name); // Output: ProductA
console.log(productB.name); // Output: ProductB在上面的代码中，我们定义了一个 Product 接口和一个抽象的 Factory 类。Factory 类包含了一个抽象的 createProduct 方法，用来创建产品对象。然后我们分别定义了两个具体的工厂类 ConcreteFactoryA 和 ConcreteFactoryB，它们都继承自 Factory 类，并实现了自己的 createProduct 方法。
接着我们定义了两个具体的产品类 ConcreteProductA 和 ConcreteProductB，它们都实现了 Product 接口，并分别设置了自己的名称。
最后，我们创建了两个工厂对象 factoryA 和 factoryB，并使用它们分别创建了两个产品对象 productA 和 productB。通过打印它们的名称，我们可以看到它们确实是我们所期望的产品对象。
抽象工厂
抽象工厂是工厂方法的进一步升级版，它可以创建一组相关的产品对象。在 TypeScript 中，我们可以使用接口来定义一组相关的产品对象，使用抽象类来实现抽象工厂类和具体工厂类。
下面是一个抽象工厂的示例代码：
// javascriptcn.com 代码示例
interface ProductA {
name: string;
}
interface ProductB {
name: string;
}
abstract class Factory {
abstract createProductA(): ProductA;
abstract createProductB(): ProductB;
}
class ConcreteFactory1 extends Factory {
createProductA(): ProductA {
return new ConcreteProductA1();
}
createProductB(): ProductB {
return new ConcreteProductB1();
}
}
class ConcreteFactory2 extends Factory {
createProductA(): ProductA {
return new ConcreteProductA2();
}
createProductB(): ProductB {
return new ConcreteProductB2();
}
}
class ConcreteProductA1 implements ProductA {
name = 'ProductA1';
}
class ConcreteProductA2 implements ProductA {
name = 'ProductA2';
}
class ConcreteProductB1 implements ProductB {
name = 'ProductB1';
}
class ConcreteProductB2 implements ProductB {
name = 'ProductB2';
}
const factory1 = new ConcreteFactory1();
const factory2 = new ConcreteFactory2();
const productA1 = factory1.createProductA();
const productB1 = factory1.createProductB();
const productA2 = factory2.createProductA();
const productB2 = factory2.createProductB();
console.log(productA1.name); // Output: ProductA1
console.log(productB1.name); // Output: ProductB1
console.log(productA2.name); // Output: ProductA2
console.log(productB2.name); // Output: ProductB2在上面的代码中，我们定义了两个接口 ProductA 和 ProductB，它们分别代表了一组相关的产品对象。然后我们定义了一个抽象的 Factory 类，它包含了两个抽象的方法 createProductA 和 createProductB，用来分别创建 ProductA 和 ProductB 对象。
接着我们分别定义了两个具体的工厂类 ConcreteFactory1 和 ConcreteFactory2，它们都继承自 Factory 类，并实现了自己的 createProductA 和 createProductB 方法，用来创建一组相关的产品对象。
然后我们分别定义了四个具体的产品类 ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2，它们分别实现了 ProductA 和 ProductB 接口，并设置了自己的名称。
最后，我们创建了两个工厂对象 factory1 和 factory2，并使用它们分别创建了两组相关的产品对象。通过打印它们的名称，我们可以看到它们确实是我们所期望的产品对象。
总结
工厂模式是一种常见的设计模式，它可以帮助我们简化对象的创建过程，提高代码的可维护性和可扩展性。在 TypeScript 中，我们可以使用简单工厂、工厂方法和抽象工厂三种类型的工厂模式，来创建不同类型的对象。使用工厂模式可以更好地利用类型系统的优势，提高代码的类型安全性和可读性，是一种非常值得推荐的编程技巧。
来源：JavaScript中文网 ，转载请注明来源 本文地址：https://www.javascriptcn.com/post/657a8c1ed2f5e1655d4ee85d