当前位置:Gxlcms > JavaScript > javascript设计模式之策略模式学习笔记

javascript设计模式之策略模式学习笔记

时间:2021-07-01 10:21:17 帮助过:7人阅读

1. 理解javascript中的策略模式

策略模式的定义是:定义一系列的算法,把它们一个个封装起来,并且使它们可以相互替换。

使用策略模式的优点如下:

优点:

      1. 策略模式利用组合,委托等技术和思想,有效的避免很多if条件语句。

      2. 策略模式提供了开放-封闭原则,使代码更容易理解和扩展。

      3. 策略模式中的代码可以复用。

一:使用策略模式计算奖金;

下面的demo是我在书上看到的,但是没有关系,我们只是来理解下策略模式的使用而已,我们可以使用策略模式来计算奖金问题;

比如公司的年终奖是根据员工的工资和绩效来考核的,绩效为A的人,年终奖为工资的4倍,绩效为B的人,年终奖为工资的3倍,绩效为C的人,年终奖为工资的2倍;现在我们使用一般的编码方式会如下这样编写代码:

  1. var calculateBouns = function(salary,level) {
  2. if(level === 'A') {
  3. return salary * 4;
  4. }
  5. if(level === 'B') {
  6. return salary * 3;
  7. }
  8. if(level === 'C') {
  9. return salary * 2;
  10. }
  11. };
  12. // 调用如下:
  13. console.log(calculateBouns(4000,'A')); // 16000
  14. console.log(calculateBouns(2500,'B')); // 7500

第一个参数为薪资,第二个参数为等级;

代码缺点如下:

calculateBouns 函数包含了很多if-else语句。

calculateBouns 函数缺乏弹性,假如还有D等级的话,那么我们需要在calculateBouns 函数内添加判断等级D的if语句;

算法复用性差,如果在其他的地方也有类似这样的算法的话,但是规则不一样,我们这些代码不能通用。

2. 使用组合函数重构代码

组合函数是把各种算法封装到一个个的小函数里面,比如等级A的话,封装一个小函数,等级为B的话,也封装一个小函数,以此类推;如下代码:

  1. var performanceA = function(salary) {
  2. return salary * 4;
  3. };
  4. var performanceB = function(salary) {
  5. return salary * 3;
  6. };
  7. var performanceC = function(salary) {
  8. return salary * 2
  9. };
  10. var calculateBouns = function(level,salary) {
  11. if(level === 'A') {
  12. return performanceA(salary);
  13. }
  14. if(level === 'B') {
  15. return performanceB(salary);
  16. }
  17. if(level === 'C') {
  18. return performanceC(salary);
  19. }
  20. };
  21. // 调用如下
  22. console.log(calculateBouns('A',4500)); // 18000

代码看起来有点改善,但是还是有如下缺点:

calculateBouns 函数有可能会越来越大,比如增加D等级的时候,而且缺乏弹性。

3. 使用策略模式重构代码

策略模式指的是 定义一系列的算法,把它们一个个封装起来,将不变的部分和变化的部分隔开,实际就是将算法的使用和实现分离出来;算法的使用方式是不变的,都是根据某个算法取得计算后的奖金数,而算法的实现是根据绩效对应不同的绩效规则;

一个基于策略模式的程序至少由2部分组成,第一个部分是一组策略类,策略类封装了具体的算法,并负责具体的计算过程。第二个部分是环境类Context,该Context接收客户端的请求,随后把请求委托给某一个策略类。我们先使用传统面向对象来实现;

如下代码:

  1. var performanceA = function(){};
  2. performanceA.prototype.calculate = function(salary) {
  3. return salary * 4;
  4. };
  5. var performanceB = function(){};
  6. performanceB.prototype.calculate = function(salary) {
  7. return salary * 3;
  8. };
  9. var performanceC = function(){};
  10. performanceC.prototype.calculate = function(salary) {
  11. return salary * 2;
  12. };
  13. // 奖金类
  14. var Bouns = function(){
  15. this.salary = null; // 原始工资
  16. this.levelObj = null; // 绩效等级对应的策略对象
  17. };
  18. Bouns.prototype.setSalary = function(salary) {
  19. this.salary = salary; // 保存员工的原始工资
  20. };
  21. Bouns.prototype.setlevelObj = function(levelObj){
  22. this.levelObj = levelObj; // 设置员工绩效等级对应的策略对象
  23. };
  24. // 取得奖金数
  25. Bouns.prototype.getBouns = function(){
  26. // 把计算奖金的操作委托给对应的策略对象
  27. return this.levelObj.calculate(this.salary);
  28. };
  29. var bouns = new Bouns();
  30. bouns.setSalary(10000);
  31. bouns.setlevelObj(new performanceA()); // 设置策略对象
  32. console.log(bouns.getBouns()); // 40000
  33. bouns.setlevelObj(new performanceB()); // 设置策略对象
  34. console.log(bouns.getBouns()); // 30000

如上代码使用策略模式重构代码,可以看到代码职责更新分明,代码变得更加清晰。

4. Javascript版本的策略模式

  1. //代码如下:
  2. var obj = {
  3. "A": function(salary) {
  4. return salary * 4;
  5. },
  6. "B" : function(salary) {
  7. return salary * 3;
  8. },
  9. "C" : function(salary) {
  10. return salary * 2;
  11. }
  12. };
  13. var calculateBouns =function(level,salary) {
  14. return obj[level](salary);
  15. };
  16. console.log(calculateBouns('A',10000)); // 40000

可以看到代码更加简单明了;

策略模式指的是定义一系列的算法,并且把它们封装起来,但是策略模式不仅仅只封装算法,我们还可以对用来封装一系列的业务规则,只要这些业务规则目标一致,我们就可以使用策略模式来封装它们;

表单效验

比如我们经常来进行表单验证,比如注册登录对话框,我们登录之前要进行验证操作:比如有以下几条逻辑:

用户名不能为空

密码长度不能小于6位。

手机号码必须符合格式。

比如HTML代码如下:

  1. <form action = "http://www.baidu.com" id="registerForm" method = "post">
  2. <p>
  3. <label>请输入用户名:</label>
  4. <input type="text" name="userName"/>
  5. </p>
  6. <p>
  7. <label>请输入密码:</label>
  8. <input type="text" name="password"/>
  9. </p>
  10. <p>
  11. <label>请输入手机号码:</label>
  12. <input type="text" name="phoneNumber"/>
  13. </p>
  14. </form>

我们正常的编写表单验证代码如下:

  1. var registerForm = document.getElementById("registerForm");
  2. registerForm.onsubmit = function(){
  3. if(registerForm.userName.value === '') {
  4. alert('用户名不能为空');
  5. return;
  6. }
  7. if(registerForm.password.value.length < 6) {
  8. alert("密码的长度不能小于6位");
  9. return;
  10. }
  11. if(!/(^1[3|5|8][0-9]{9}$)/.test(registerForm.phoneNumber.value)) {
  12. alert("手机号码格式不正确");
  13. return;
  14. }
  15. }


但是这样编写代码有如下缺点:

1.registerForm.onsubmit 函数比较大,代码中包含了很多if语句;

2.registerForm.onsubmit 函数缺乏弹性,如果增加了一种新的效验规则,或者想把密码的长度效验从6改成8,我们必须改registerForm.onsubmit 函数内部的代码。违反了开放-封闭原则。

3. 算法的复用性差,如果在程序中增加了另外一个表单,这个表单也需要进行一些类似的效验,那么我们可能又需要了;

下面我们可以使用策略模式来重构表单效验;

第一步我们先来封装策略对象;如下代码:

  1. var strategy = {
  2. isNotEmpty: function(value,errorMsg) {
  3. if(value === '') {
  4. return errorMsg;
  5. }
  6. },
  7. // 限制最小长度
  8. minLength: function(value,length,errorMsg) {
  9. if(value.length < length) {
  10. return errorMsg;
  11. }
  12. },
  13. // 手机号码格式
  14. mobileFormat: function(value,errorMsg) {
  15. if(!/(^1[3|5|8][0-9]{9}$)/.test(value)) {
  16. return errorMsg;
  17. }
  18. }
  19. };

接下来我们准备实现Validator类,Validator类在这里作为Context,负责接收用户的请求并委托给strategy 对象,如下代码:

  1. var Validator = function(){
  2. this.cache = []; // 保存效验规则
  3. };
  4. Validator.prototype.add = function(dom,rule,errorMsg) {
  5. var str = rule.split(":");
  6. this.cache.push(function(){
  7. // str 返回的是 minLength:6
  8. var strategy = str.shift();
  9. str.unshift(dom.value); // 把input的value添加进参数列表
  10. str.push(errorMsg); // 把errorMsg添加进参数列表
  11. return strategys[strategy].apply(dom,str);
  12. });
  13. };
  14. Validator.prototype.start = function(){
  15. for(var i = 0, validatorFunc; validatorFunc = this.cache[i++]; ) {
  16. var msg = validatorFunc(); // 开始效验 并取得效验后的返回信息
  17. if(msg) {
  18. return msg;
  19. }
  20. }
  21. };

Validator类在这里作为Context,负责接收用户的请求并委托给strategys对象。上面的代码中,我们先创建一个Validator对象,然后通过validator.add方法往validator对象中添加一些效验规则,validator.add方法接收3个参数,如下代码:

validator.add(registerForm.password,'minLength:6','密码长度不能小于6位');

registerForm.password 为效验的input输入框dom节点;

minLength:6: 是以一个冒号隔开的字符串,冒号前面的minLength代表客户挑选的strategys对象,冒号后面的数字6表示在效验过程中所必须验证的参数,minLength:6的意思是效验 registerForm.password 这个文本输入框的value最小长度为6位;如果字符串中不包含冒号,说明效验过程中不需要额外的效验信息;

第三个参数是当效验未通过时返回的错误信息;

当我们往validator对象里添加完一系列的效验规则之后,会调用validator.start()方法来启动效验。如果validator.start()返回了一个errorMsg字符串作为返回值,说明该次效验没有通过,此时需要registerForm.onsubmit方法返回false来阻止表单提交。下面我们来看看初始化代码如下:

  1. var validateFunc = function(){
  2. var validator = new Validator(); // 创建一个Validator对象
  3. /* 添加一些效验规则 */
  4. validator.add(registerForm.userName,'isNotEmpty','用户名不能为空');
  5. validator.add(registerForm.password,'minLength:6','密码长度不能小于6位');
  6. validator.add(registerForm.userName,'mobileFormat','手机号码格式不正确');
  7. var errorMsg = validator.start(); // 获得效验结果
  8. return errorMsg; // 返回效验结果
  9. };
  10. var registerForm = document.getElementById("registerForm");
  11. registerForm.onsubmit = function(){
  12. var errorMsg = validateFunc();
  13. if(errorMsg){
  14. alert(errorMsg);
  15. return false;
  16. }
  17. }

下面是所有的代码如下:

  1. var strategys = {
  2. isNotEmpty: function(value,errorMsg) {
  3. if(value === '') {
  4. return errorMsg;
  5. }
  6. },
  7. // 限制最小长度
  8. minLength: function(value,length,errorMsg) {
  9. if(value.length < length) {
  10. return errorMsg;
  11. }
  12. },
  13. // 手机号码格式
  14. mobileFormat: function(value,errorMsg) {
  15. if(!/(^1[3|5|8][0-9]{9}$)/.test(value)) {
  16. return errorMsg;
  17. }
  18. }
  19. };
  20. var Validator = function(){
  21. this.cache = []; // 保存效验规则
  22. };
  23. Validator.prototype.add = function(dom,rule,errorMsg) {
  24. var str = rule.split(":");
  25. this.cache.push(function(){
  26. // str 返回的是 minLength:6
  27. var strategy = str.shift();
  28. str.unshift(dom.value); // 把input的value添加进参数列表
  29. str.push(errorMsg); // 把errorMsg添加进参数列表
  30. return strategys[strategy].apply(dom,str);
  31. });
  32. };
  33. Validator.prototype.start = function(){
  34. for(var i = 0, validatorFunc; validatorFunc = this.cache[i++]; ) {
  35. var msg = validatorFunc(); // 开始效验 并取得效验后的返回信息
  36. if(msg) {
  37. return msg;
  38. }
  39. }
  40. };
  41. var validateFunc = function(){
  42. var validator = new Validator(); // 创建一个Validator对象
  43. /* 添加一些效验规则 */
  44. validator.add(registerForm.userName,'isNotEmpty','用户名不能为空');
  45. validator.add(registerForm.password,'minLength:6','密码长度不能小于6位');
  46. validator.add(registerForm.userName,'mobileFormat','手机号码格式不正确');
  47. var errorMsg = validator.start(); // 获得效验结果
  48. return errorMsg; // 返回效验结果
  49. };
  50. var registerForm = document.getElementById("registerForm");
  51. registerForm.onsubmit = function(){
  52. var errorMsg = validateFunc();
  53. if(errorMsg){
  54. alert(errorMsg);
  55. return false;
  56. }
  57. };

如上使用策略模式来编写表单验证代码可以看到好处了,我们通过add配置的方式就完成了一个表单的效验;这样的话,那么代码可以当做一个组件来使用,并且可以随时调用,在修改表单验证规则的时候,也非常方便,通过传递参数即可调用;

给某个文本输入框添加多种效验规则,上面的代码我们可以看到,我们只是给输入框只能对应一种效验规则,比如上面的我们只能效验输入框是否为空,validator.add(registerForm.userName,'isNotEmpty','用户名不能为空');但是如果我们既要效验输入框是否为空,还要效验输入框的长度不要小于10位的话,那么我们期望需要像如下传递参数:

validator.add(registerForm.userName,[{strategy:'isNotEmpty',errorMsg:'用户名不能为空'},{strategy: 'minLength:6',errorMsg:'用户名长度不能小于6位'}])

我们可以编写代码如下:

  1. // 策略对象
  2. var strategys = {
  3. isNotEmpty: function(value,errorMsg) {
  4. if(value === '') {
  5. return errorMsg;
  6. }
  7. },
  8. // 限制最小长度
  9. minLength: function(value,length,errorMsg) {
  10. if(value.length < length) {
  11. return errorMsg;
  12. }
  13. },
  14. // 手机号码格式
  15. mobileFormat: function(value,errorMsg) {
  16. if(!/(^1[3|5|8][0-9]{9}$)/.test(value)) {
  17. return errorMsg;
  18. }
  19. }
  20. };
  21. var Validator = function(){
  22. this.cache = []; // 保存效验规则
  23. };
  24. Validator.prototype.add = function(dom,rules) {
  25. var self = this;
  26. for(var i = 0, rule; rule = rules[i++]; ){
  27. (function(rule){
  28. var strategyAry = rule.strategy.split(":");
  29. var errorMsg = rule.errorMsg;
  30. self.cache.push(function(){
  31. var strategy = strategyAry.shift();
  32. strategyAry.unshift(dom.value);
  33. strategyAry.push(errorMsg);
  34. return strategys[strategy].apply(dom,strategyAry);
  35. });
  36. })(rule);
  37. }
  38. };
  39. Validator.prototype.start = function(){
  40. for(var i = 0, validatorFunc; validatorFunc = this.cache[i++]; ) {
  41. var msg = validatorFunc(); // 开始效验 并取得效验后的返回信息
  42. if(msg) {
  43. return msg;
  44. }
  45. }
  46. };
  47. // 代码调用
  48. var registerForm = document.getElementById("registerForm");
  49. var validateFunc = function(){
  50. var validator = new Validator(); // 创建一个Validator对象
  51. /* 添加一些效验规则 */
  52. validator.add(registerForm.userName,[
  53. {strategy: 'isNotEmpty',errorMsg:'用户名不能为空'},
  54. {strategy: 'minLength:6',errorMsg:'用户名长度不能小于6位'}
  55. ]);
  56. validator.add(registerForm.password,[
  57. {strategy: 'minLength:6',errorMsg:'密码长度不能小于6位'},
  58. ]);
  59. validator.add(registerForm.phoneNumber,[
  60. {strategy: 'mobileFormat',errorMsg:'手机号格式不正确'},
  61. ]);
  62. var errorMsg = validator.start(); // 获得效验结果
  63. return errorMsg; // 返回效验结果
  64. };
  65. // 点击确定提交
  66. registerForm.onsubmit = function(){
  67. var errorMsg = validateFunc();
  68. if(errorMsg){
  69. alert(errorMsg);
  70. return false;
  71. }
  72. }

注意:如上代码都是按照书上来做的,都是看到书的代码,最主要我们理解策略模式实现,比如上面的表单验证功能是这样封装的代码,我们平时使用jquery插件表单验证代码原来是这样封装的,为此我们以后也可以使用这种方式来封装表单等学习;

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

人气教程排行