JavaScript使用策略模式实现算法的替换「js策略模式表单验证」

admin4个月前 (05-28)网络知识39

策略模式是一种行为设计模式，它定义了一系列算法，并将每个算法封装在一个具有共同接口的类中，使得它们可以相互替换，在JavaScript中，我们可以使用策略模式来实现算法的替换。

JavaScript使用策略模式实现算法的替换「js策略模式表单验证」-图1

我们需要定义一个策略接口，该接口包含一个用于执行算法的方法，我们可以创建实现该接口的具体策略类，我们可以创建一个上下文类，该类接受一个策略对象作为参数，并在需要时调用其执行算法的方法。

以下是一个简单的示例，演示了如何使用策略模式实现两个不同的排序算法（冒泡排序和快速排序）的替换：

// 定义策略接口
class SortingStrategy {
  sort(arr) {
    throw new Error("Sorting strategy not implemented");
  }
}

// 实现冒泡排序策略
class BubbleSortStrategy extends SortingStrategy {
  sort(arr) {
    const n = arr.length;
    for (let i = 0; i < n - 1; i++) {
      for (let j = 0; j < n - i - 1; j++) {
        if (arr[j] > arr[j + 1]) {
          [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
        }
      }
    }
    return arr;
  }
}

// 实现快速排序策略
class QuickSortStrategy extends SortingStrategy {
  sort(arr) {
    if (arr.length <= 1) {
      return arr;
    }
    const pivot = arr[Math.floor(arr.length / 2)];
    const left = [];
    const right = [];
    for (let i = 0; i < arr.length; i++) {
      if (arr[i] < pivot) {
        left.push(arr[i]);
      } else {
        right.push(arr[i]);
      }
    }
    return [...this.sort(left), pivot, ...this.sort(right)];
  }
}

// 创建上下文类
class Sorter {
  constructor(strategy) {
    this.strategy = strategy;
  }

  setStrategy(strategy) {
    this.strategy = strategy;
  }

  sort(arr) {
    return this.strategy.sort(arr);
  }
}

// 使用冒泡排序策略对数组进行排序
const bubbleSorter = new Sorter(new BubbleSortStrategy());
console.log(bubbleSorter.sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])); // [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

// 使用快速排序策略对数组进行排序
bubbleSorter.setStrategy(new QuickSortStrategy());
console.log(bubbleSorter.sort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])); // [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

在这个示例中，我们首先定义了一个`SortingStrategy`接口，然后创建了两个实现该接口的具体策略类：`BubbleSortStrategy`和`QuickSortStrategy`，接下来，我们创建了一个`Sorter`上下文类，该类接受一个策略对象作为参数，并在需要时调用其执行算法的方法，我们分别使用冒泡排序策略和快速排序策略对数组进行排序，通过改变`Sorter`对象的`strategy`属性，我们可以很容易地在两种排序算法之间进行切换。