js --策略模式

策略模式的定义：

将算法一个个的单独进行封装，并且使他们可以相互替换。此模式让算法的变化不会影响到使用算法的客户。

 先回顾一下，我们在做项目的过程中，是不是经常会遇见因为业务逻辑的关系，我们会写好多的is-else语句进行判断，或者使用switch语句，在后期添加新的需求的时候，比较头疼的需要去改这些判断语句，而且有时候会，添加一条判断语句，一不小心会导致所有的判断都失效呢?举一个之前项目中用到的例子把，简化一下。有一个按钮在不同的条件下，跳转到不同的页面，如下：

toseeHouse() {
            switch(this.activeIndex){
                case 0:uni.navigateTo({
                            url: '/0'
                        });
                    break;
                case 1:uni.navigateTo({
                            url: '/1'
                        });
                    break;
                case 2:uni.navigateTo({
                            url: '/2'
                        });
                    break;
                case 3:uni.navigateTo({
                            url: '/3'
                        });
                    break;
            }
        },

这段代码带来的问题主要是在增加新的需求的时候，我们还需要修改这段代码的整体逻辑。

然后根据策略模式，我们将一系列的算法单独封装出去，使用哪个，调用哪个方法。

JavaScript版本的策略模式

let obj = {
        '0': function() {
            return '0'
        },
        '1': function() {
            return '1'
        },
        '2': function() {
            return '2'
        }
    }
    console.log('111111111', obj['0']()) //0

这样，就避免了if-else 语句的判断，如果增加了新的业务逻辑，我们可以直接修改算法，而不会影响用户的使用。

使用策略模式重构代码，可以消除程序中大片的条件分支语句。在实际开发的过程中，我们通常会把算法的含义扩散开来，是策略模式也可以封装一系列的“业务规则”。只要这些业务规则的指向的目标一致，并且可以被替换使用，我们就可以使用策略模式来封装他们。

在举一个在网上看到的例子，应该算是比较经典的把，因为 好多博客中都以这个例子为例，就是计算奖金的这个例子。

传统版的策略模式：

 var performanceA = function() {

    }
    performanceA.prototype.calculate = function(salary) {
        return salary*4;
    }
    var performanceB = function() {}
    performanceB.prototype.calculate = function(salary) {
        return salary*3
    }
    var performanceC = function() {}
    performanceC.prototype.calculate = function(salary) {
        return salary*2
    }
    //奖金类
    var Bouns = function() {
        this.salary = null; //原始工资
        this.levelObj = null; //绩效等级对应的策略模式
    }
    Bouns.prototype.setSalary = function(salary) {
        // 保存员工的原始工资
        this.salary = salary;
    }
    Bouns.prototype.setlevelObj = function(levelObj) {
        // 设置员工绩效等级对应的策略模式
        this.levelObj = levelObj;
    }
    Bouns.prototype.getBouns = function() {
        // 把计算奖金的操作委托给对应的策略对象
        return this.levelObj.calculate(this.salary)
    }
    var bouns = new Bouns();
    bouns.setSalary(1000);
    bouns.setlevelObj(new performanceA());
    console.log(bouns.getBouns()) // 4000
    bouns.setlevelObj(new performanceB())
    console.log(bouns.getBouns()) // 3000

策略模式 应该至少由两部分组成，一部分使策略类，就是里面封装了具体的算法。并且负责具体的计算过程。第二个部门就是环境类Context。该Contex接收客户的请求，然后把请求委托给符合要求的某一个策略类。

策略模式的优点：

优点： 

- 避免使用大量的if-else语句，使代码块简洁，易读。

- 符合设计原则中的开放-封闭原则，面向扩展开放，面向修改关闭。

- 复用性高

缺点：

- 增加了许多策略类或者策略对象

总结：

策略模式定义了一系列的算法，从概念上讲，所有的这些算法都是做相同的事情，只是实现不同，他可以以相同的方式调用所有的方法，减少了各种算法类与使用算法类之间的耦合。