设计模式

[yangchongduo]

设计模式 验证设计模式是否成功，复用和增加情况

• “找出程序中变化的地方，并将变化封装起来”
  • 所有设计模式的实现都遵循一条原则，即“找出程序中变化的地方，并将变化封装起来”。 一个程序的设计总是可以分为可变的部分和不变的部分。当我们找出可变的部分，并且把这些部 分封装起来，那么剩下的就是不变和稳定的部分。这些不变和稳定的部分是非常容易复用的。这 也是设计模式为什么描写的是可复用面向对象软件基础的原因。
• 很多设计模式可用函数式完成
• 合并重复的条件片段
  • 如果一个函数体内有一些条件分支语句，而这些条件分支语句内部散布了一些重复的代码， 那么就有必要进行合并去重工作。
• 提炼函数:
• 如果在函数中有一段代码可以被独立出来，那我们最好把这些代码放进另外一个独立的函数中。这是一种很常见的优化工作
• 函数多个参数的时候，必须换成对象,取值不会错，同时还能在函数({name='rr',age='rrr'}) {}
• 利用对象的多态性，导演在发布消息时，就不必考虑各个对象接到消息后应该做什么。对象 应该做什么并不是临时决定的，而是已经事先约定和排练完毕的。每个对象应该做什么，已经成 为了该对象的一个方法，被安装在对象的内部，每个对象负责它们自己的行为。所以这些对象可 以根据同一个消息，有条不紊地分别进行各自的工作。
  将行为分布在各个对象中，并让这些对象各自负责自己的行为，这正是面向对象设计的优点。

项目实战

• 场景1

// 谷歌地图
/**
 * 最开始的情况*
 * /
var googleMap = ()=> console.log('google');
var baiduMap =() => console.log('baiduMap');
var sogouMap = () => console.log('sogouMap');
var renderMap= (type)=>{
  if (type == 'google') {
    googleMap()
  }else if(type== 'baidu'){
    baiduMap()
  }else{
    sogouMap()
  }
}
/**
 * 如果在增加一种情况需要改很多东西，renderMap 是需要改动的 写的太low的了
 */
var googleMap ={
  show() {
    console.log('谷歌');
  }
}
var baiduMap = {
  show() {
    console.log('baidu');
  }
}
var sogouMap={
  show() {
    console.log('sugou');
  }
}
// type 不要使用  不变的进行   不可变的进行隔离  隔离是相对的，�可变的进行封装；
// 如果再多一种形式 ，不可变的隔离之后不能做任何的操作，分装组件也是  对于组件而言 可变的进行封装
var renderMap= (type)=>{
  if (type == 'google') {
    googleMap.show()
  }else if(type== 'baidu'){
    baiduMap.show()
  }else{
    sogouMap.show()
  }
}
// renderMap('google')
// renderMap('baidu')


/**
 * 做什么   怎么去做是分开的；
 */
var renderMap=(map)=>{
  map.show instanceof Function ? map.show() : null;
}
var renderMap =(map)=> map.show instanceof Function ? map.show() : null;
renderMap(googleMap)
PS:  

• 场景2 根据不同类型执行不同的逻辑

var calculateBonus = (performanceLevel, salary) => {
  // 不可变进行隔离，可变的进行封装，
  // 如果在增加一种情况好增加吗？
  // 如果想复用这段代码如何能够复用。 能不能进封装； 如果可以独立得逻辑，抽离成函数
  if (performanceLevel == 's') {
    return salary *5 
  }
  if (performanceLevel == 'a') {
    return salary * 3 //salary * 5 是算法是比较简单的
  }
}
calculateBonus('s',4400);

设计模式 策略模式
var strategies = {
  'a':(salary)=>(salary * 4),
  'b':(salary)=>(salary * 3)
}
var calculateBonus = (level,salary ) =>(strategies[ level ]( salary ))
函数式 这些“算法”可以被封装到函数中并且四处传递，也就是我们常说的“高阶 函数”。

var S = function (salary) {
	return salary * 4;
};
var A = function (salary) {
	return salary * 3;
};

var B = function (salary) {
	return salary * 2;
};
var calculateBonus = function (func, salary) {
	return func(salary);

};
calculateBonus(S, 10000);
函数 vs 对象
var stages={
  's':salary=> salary*4,
  'a':salary=> salary*3
}
var fn = (type,salary)=>stages[type](salary)
console.log(fn('s',2000));
  

//  函数式的作用是什么，写成函数到处传播 函数式更加好
var S = salary => salary*4;
var fn = (S,salary)=>S(salary);
console.log(fn(S,3000));

[etheranl]

赞