策略模式：灵活处理算法，代码重用利器

前端

2023-11-02 05:43:57

什么是策略模式？

策略模式是一种行为设计模式，旨在将算法封装起来，使其可以相互替换。简单来说，就是把不同的算法打包成独立的策略类，让调用者根据不同情况选择合适的策略来完成任务。

策略模式的好处

使用策略模式，可以带来诸多好处，包括：

提高代码重用性： 把不同算法封装成独立的策略类，可以方便地重用这些算法，避免重复编写代码。
提高代码可理解性： 将算法与调用者分离，使代码结构更清晰，更容易理解和维护。
提高代码可靠性： 策略类负责实现具体算法，而调用者只负责选择合适的策略，从而提高代码的可靠性。

策略模式的应用场景

策略模式广泛应用于各种场景，例如：

排序算法： 可以使用策略模式来实现不同的排序算法，比如冒泡排序、快速排序、归并排序等。
数据验证： 可以使用策略模式来实现不同的数据验证算法，比如电子邮件验证、手机号码验证、身份证号码验证等。
压缩算法： 可以使用策略模式来实现不同的压缩算法，比如 Gzip 压缩、Bzip2 压缩、LZMA 压缩等。

策略模式的实现

在 JavaScript 中，实现策略模式非常简单，可以按照以下步骤进行：

定义一个策略接口，其中包含所有策略类需要实现的方法。
定义多个策略类，每个策略类实现策略接口中的方法，并提供具体的算法实现。
定义一个上下文类，负责选择和调用合适的策略类。

策略模式的示例

以下是一个简单的 JavaScript 策略模式示例，演示如何使用策略模式来实现不同的排序算法：

// 定义策略接口
interface SortStrategy {
  sort(array: number[]): number[];
}

// 定义冒泡排序策略类
class BubbleSortStrategy implements SortStrategy {
  sort(array: number[]): number[] {
    for (let i = 0; i < array.length; i++) {
      for (let j = 0; j < array.length - i - 1; j++) {
        if (array[j] > array[j + 1]) {
          let temp = array[j];
          array[j] = array[j + 1];
          array[j + 1] = temp;
        }
      }
    }
    return array;
  }
}

// 定义快速排序策略类
class QuickSortStrategy implements SortStrategy {
  sort(array: number[]): number[] {
    if (array.length <= 1) {
      return array;
    }

    let pivot = array[array.length - 1];
    let leftArray: number[] = [];
    let rightArray: number[] = [];

    for (let i = 0; i < array.length - 1; i++) {
      if (array[i] < pivot) {
        leftArray.push(array[i]);
      } else {
        rightArray.push(array[i]);
      }
    }

    return this.sort(leftArray).concat(pivot, this.sort(rightArray));
  }
}

// 定义归并排序策略类
class MergeSortStrategy implements SortStrategy {
  sort(array: number[]): number[] {
    if (array.length <= 1) {
      return array;
    }

    let midIndex = Math.floor(array.length / 2);
    let leftArray = array.slice(0, midIndex);
    let rightArray = array.slice(midIndex);

    return this.merge(this.sort(leftArray), this.sort(rightArray));
  }

  merge(leftArray: number[], rightArray: number[]): number[] {
    let mergedArray: number[] = [];
    let leftIndex = 0;
    let rightIndex = 0;

    while (leftIndex < leftArray.length && rightIndex < rightArray.length) {
      if (leftArray[leftIndex] < rightArray[rightIndex]) {
        mergedArray.push(leftArray[leftIndex]);
        leftIndex++;
      } else {
        mergedArray.push(rightArray[rightIndex]);
        rightIndex++;
      }
    }

    while (leftIndex < leftArray.length) {
      mergedArray.push(leftArray[leftIndex]);
      leftIndex++;
    }

    while (rightIndex < rightArray.length) {
      mergedArray.push(rightArray[rightIndex]);
      rightIndex++;
    }

    return mergedArray;
  }
}

// 定义上下文类
class SortContext {
  private strategy: SortStrategy;

  constructor(strategy: SortStrategy) {
    this.strategy = strategy;
  }

  sort(array: number[]): number[] {
    return this.strategy.sort(array);
  }
}

// 使用策略模式排序数组
const array = [1, 5, 3, 2, 4];

const bubbleSortContext = new SortContext(new BubbleSortStrategy());
const bubbleSortedArray = bubbleSortContext.sort(array);

const quickSortContext = new SortContext(new QuickSortStrategy());
const quickSortedArray = quickSortContext.sort(array);

const mergeSortContext = new SortContext(new MergeSortStrategy());
const mergeSortedArray = mergeSortContext.sort(array);

console.log('Bubble sorted array:', bubbleSortedArray);
console.log('Quick sorted array:', quickSortedArray);
console.log('Merge sorted array:', mergeSortedArray);