TypeScript 中的策略模式

策略模式（Strategy Pattern）是一种行为设计模式，它允许你定义一系列算法，并将每个算法封装起来，使它们可以相互替换。下面介绍策略模式在 TypeScript 中的实现。
策略模式基本概念

策略模式包含三个主要部分：

• Context（上下文）：维护一个策略对象的引用
  
• Strategy（策略接口）：定义所有支持的算法的公共接口
  
• ConcreteStrategy（具体策略）：实现策略接口的具体算法
  

基础实现

1. 定义策略接口

1. // 策略接口
2. interface PaymentStrategy {
3.   pay(amount: number): void;
4. }

复制代码

2. 实现具体策略类

1. // 信用卡支付策略
2. class CreditCardPayment implements PaymentStrategy {
3.   private cardNumber: string;
4.   private name: string;
6.   constructor(cardNumber: string, name: string) {
7.     this.cardNumber = cardNumber;
8.     this.name = name;
9.   }
11.   pay(amount: number): void {
12.     console.log(`使用信用卡支付 $${amount}`);
13.     console.log(`卡号: ${this.cardNumber}, 持卡人: ${this.name}`);
14.   }
15. }
17. // PayPal支付策略
18. class PayPalPayment implements PaymentStrategy {
19.   private email: string;
21.   constructor(email: string) {
22.     this.email = email;
23.   }
25.   pay(amount: number): void {
26.     console.log(`使用PayPal支付 $${amount}`);
27.     console.log(`邮箱: ${this.email}`);
28.   }
29. }
31. // 加密货币支付策略
32. class CryptoPayment implements PaymentStrategy {
33.   private walletAddress: string;
35.   constructor(walletAddress: string) {
36.     this.walletAddress = walletAddress;
37.   }
39.   pay(amount: number): void {
40.     console.log(`使用加密货币支付 $${amount}`);
41.     console.log(`钱包地址: ${this.walletAddress}`);
42.   }
43. }

复制代码

3. 创建上下文类

1. // 支付上下文
2. class PaymentContext {
3.   private strategy: PaymentStrategy;
5.   constructor(strategy: PaymentStrategy) {
6.     this.strategy = strategy;
7.   }
9.   // 设置支付策略
10.   setStrategy(strategy: PaymentStrategy): void {
11.     this.strategy = strategy;
12.   }
14.   // 执行支付
15.   executePayment(amount: number): void {
16.     this.strategy.pay(amount);
17.   }
18. }

复制代码

4. 使用示例

1. // 使用示例
2. const paymentContext = new PaymentContext(new CreditCardPayment("1234-5678-9012", "张三"));
4. // 使用信用卡支付
5. paymentContext.executePayment(100);
7. // 切换到PayPal支付
8. paymentContext.setStrategy(new PayPalPayment("zhang@example.com"));
9. paymentContext.executePayment(200);
11. // 切换到加密货币支付
12. paymentContext.setStrategy(new CryptoPayment("1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"));
13. paymentContext.executePayment(300);

复制代码

更复杂的示例：排序策略

1. // 排序策略接口
2. interface SortStrategy<T> {
3.   sort(items: T[]): T[];
4. }
6. // 冒泡排序策略
7. class BubbleSort<T> implements SortStrategy<T> {
8.   sort(items: T[]): T[] {
9.     console.log("使用冒泡排序");
10.     const arr = [...items];
11.     for (let i = 0; i < arr.length; i++) {
12.       for (let j = 0; j < arr.length - i - 1; j++) {
13.         if (arr[j] > arr[j + 1]) {
14.           [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
15.         }
16.       }
17.     }
18.     return arr;
19.   }
20. }
22. // 快速排序策略
23. class QuickSort<T> implements SortStrategy<T> {
24.   sort(items: T[]): T[] {
25.     console.log("使用快速排序");
26.     if (items.length <= 1) return items;
27.    
28.     const pivot = items[0];
29.     const left = [];
30.     const right = [];
31.    
32.     for (let i = 1; i < items.length; i++) {
33.       if (items[i] < pivot) {
34.         left.push(items[i]);
35.       } else {
36.         right.push(items[i]);
37.       }
38.     }
39.    
40.     return [...this.sort(left), pivot, ...this.sort(right)];
41.   }
42. }
44. // 排序上下文
45. class Sorter<T> {
46.   private strategy: SortStrategy<T>;
48.   constructor(strategy: SortStrategy<T>) {
49.     this.strategy = strategy;
50.   }
52.   setStrategy(strategy: SortStrategy<T>): void {
53.     this.strategy = strategy;
54.   }
56.   sort(items: T[]): T[] {
57.     return this.strategy.sort(items);
58.   }
59. }
61. // 使用示例
62. const numbers = [64, 34, 25, 12, 22, 11, 90];
63. const sorter = new Sorter<number>(new BubbleSort<number>());
65. console.log("排序前:", numbers);
66. console.log("排序后:", sorter.sort(numbers));
68. // 切换排序策略
69. sorter.setStrategy(new QuickSort<number>());
70. console.log("使用快速排序:", sorter.sort(numbers));

复制代码

策略模式的优点

• 开闭原则：可以引入新策略而不修改现有代码
  
• 消除条件语句：避免大量的 if-else 或 switch-case 语句
  
• 算法复用：可以在不同的上下文中复用策略
  
• 测试友好：每个策略都可以独立测试
  

适用场景

• 一个系统需要在多种算法中选择一种时
  
• 有多个条件语句来选择不同的行为时
  
• 需要动态切换算法时
  
• 希望将算法的使用与实现分离时
  

策略模式是非常实用的设计模式，特别适合处理需要灵活切换行为的场景。
参考资料

• https://refactoring.guru/design-patterns/strategy
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！