设计模式 -- 策略模式（传统面向对象与JavaScript 的对比实现）

这篇具有很好参考价值的文章主要介绍了设计模式 -- 策略模式（传统面向对象与JavaScript 的对比实现）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

设计模式 – 策略模式（传统面向对象与JavaScript 的对比实现）

使用策略模式计算年终奖

规则：根据员工的工资基数和年底绩效情况计算年终奖

初级实现

		const calculateBonus = function (performanceLevel, salary) {
            if (performanceLevel === 'S') {
                return salary * 4;
            }
            if (performanceLevel === 'A') {
                return salary * 3;
            }
            if (performanceLevel === 'B') {
                return salary * 2;
            }
        };
        calculateBonus('B', 20000); // 输出:40000 
        calculateBonus('S', 6000); // 输出:24000

缺点

多重 if else
违反开发-封闭原则，可维护性差
复用性差

使用组合函数重构代码

使用组合函数来重构代码，把各种算法封装到一个个的小函数里面，这些小函数有着良好的命名，可以一目了然地知道它对应着哪种算法，它们也可以被复用在程序的其他地方。

		const performanceS = function (salary) {
            return salary * 4;
        };
        const performanceA = function (salary) {
            return salary * 3;
        };
        const performanceB = function (salary) {
            return salary * 2;
        };
        const calculateBonus = function (performanceLevel, salary) {
            if (performanceLevel === 'S') {
                return performanceS(salary);
            }
            if (performanceLevel === 'A') {
                return performanceA(salary);
            }
            if (performanceLevel === 'B') {
                return performanceB(salary);
            }
        };
        calculateBonus('A', 10000); // 输出:30000

缺点

程序得到了一定的改善，但这种改善非常有限，我们依然没有解决最重要的问题:

calculateBonus 函数有可能越来越庞大
而且在系统变化的时候缺乏弹性

使用策略模式重构代码

策略模式指的是定义一系列的算法，把它们一个个封装起来。将不变的部分和变化的部分隔开是每个设计模式的主题，策略模式也不例外，策略模式的目的就是将算法的使用与算法的实现分离开来。

一个基于策略模式的程序至少由两部分组成。第一个部分是一组策略类，策略类封装了具体的算法，并负责具体的计算过程。第二个部分是环境类 Context，Context 接受客户的请求，随后把请求委托给某一个策略类。要做到这点，说明 Context 中要维持对某个策略对象的引用。

更详细一点，就是: 定义一系列的算法，把它们各自封装成策略类，算法被封装在策略类内部的方法里。在客户对 Context 发起请求的时候，Context 总是把请求委托给这些策略对象中间的某一个进行计算。

传统的面向对象的策略模式实现方法

 const performanceS = function () { };
        performanceS.prototype.calculate = function (salary) {
            return salary * 4;
        };
        const performanceA = function () { };
        performanceA.prototype.calculate = function (salary) {
            return salary * 3;
        };
        const performanceB = function () { };
        performanceB.prototype.calculate = function (salary) {
            return salary * 2;
        };

        const Bonus = function () {
            this.salary = null; // 原始工资
            this.strategy = null;// 绩效等级对应的策略对象
        };

        Bonus.prototype.setSalary = function (salary) {
            this.salary = salary; // 设置员工的原始工资
        };

        Bonus.prototype.setStrategy = function (strategy) {
            this.strategy = strategy; // 设置员工绩效等级对应的策略对象
        };

        Bonus.prototype.getBonus = function () { // 取得奖金数额
            return this.strategy.calculate(this.salary); // 把计算奖金的操作委托给对应的策略对象
        };


        const bonus = new Bonus();

        bonus.setSalary(10000);
        bonus.setStrategy(new performanceS()); // 设置策略对象
        console.log(bonus.getBonus()); // 输出:40000 
        bonus.setStrategy(new performanceA()); // 设置策略对象
        console.log(bonus.getBonus()); // 输出:30000

可以看到通过策略模式重构之后，代码变得更加清晰，各个类的职责更加鲜明。

最终实现 – JavaScript 版本的策略模式

        const strategies = {
            "S": function (salary) {
                return salary * 4;
            },
            "A": function (salary) {
                return salary * 3;
            },
            "B": function (salary) {
                return salary * 2;
            }
        };
        const calculateBonus = function (level, salary) {
            return strategies[level](salary);
        };
        console.log(calculateBonus('S', 20000));
        console.log(calculateBonus('A', 10000));

在 JavaScript 语言中，函数也是对象，所以更简单和直接的做法是把 strategy 直接定义为函数。
同样，Context 也没有必要必须用 Bonus 类来表示，我们依然用 calculateBonus 函数充当Context 来接受用户的请求。经过改造，代码的结构变得更加简洁。

多态

通过使用策略模式重构代码，我们消除了原程序中大片的条件分支语句。所有跟计算奖金有关的逻辑不再放在 Context 中，而是分布在各个策略对象中。Context 并没有计算奖金的能力，而是把这个职责委托给了某个策略对象。每个策略对象负责的算法已被各自封装在对象内部。当我们对这些策略对象发出“计算奖金”的请求时，它们会返回各自不同的计算结果，这正是对象多态性的体现，也是“它们可以相互替换”的目的。替换 Context 中当前保存的策略对象，便能执行不同的算法来得到我们想要的结果。

终极实现 – JavaScript 版本的精简版实现

使用 map 来做映射（配置文件），若以后新增规则，则直接在map中增加，保证了可维护性

		const map = {
            'S': 4,
            'A': 3,
            'B': 2
        }
        const calculateBonus = function (level, salary) {
            return map[level] * salary;
        };
        console.log(calculateBonus('S', 20000));
        console.log(calculateBonus('A', 10000));

策略模式的优点

策略模式利用组合、委托和多态等技术和思想，可以有效地避免多重条件选择语句。
策略模式提供了对开放—封闭原则的完美支持，将算法封装在独立的 strategy 中，使得它们易于切换，易于理解，易于扩展。
策略模式中的算法也可以复用在系统的其他地方，从而避免许多重复的复制粘贴工作。
在策略模式中利用组合和委托来让 Context 拥有执行算法的能力，这也是继承的一种更轻便的替代方案。

策略模式的缺点

首先，使用策略模式会在程序中增加许多策略类或者策略对象，但实际上这比把它们负责的逻辑堆砌在 Context 中要好。

其次，要使用策略模式，必须了解所有的 strategy，必须了解各个 strategy 之间的不同点，这样才能选择一个合适的 strategy。比如，我们要选择一种合适的旅游出行路线，必须先了解选择飞机、火车、自行车等方案的细节。此时 strategy 要向客户暴露它的所有实现，这是违反最少知识原则的。

参考文献：
JavaScript 设计模式与开发实践（by 曾探）文章来源地址https://www.toymoban.com/news/detail-667310.html

到了这里，关于设计模式 -- 策略模式（传统面向对象与JavaScript 的对比实现）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！