设计原则

做人是要有原则的，做事怎怎么能没有原则呢
做设计… 你总要有点中心思想吧

什么是设计

大家都是成年人了，做事做事要三思而后行，记得曾经听别人说过，成年的世界没有对错，只有利弊，我们通过自己所学的只是对某种事物的规划就是设计了(这是我自己瞎说的，看看就好了)

• 按照哪一种思路或者标准实现功能
• 功能相同，可以有不同的设计方式
• 如果需求不断变化，设计的作用才能体现出来

SOLID五大设计原则

首字母	指代	概念
S	单一职责原则	单一功能原则认为对象应该仅具有一种单一功能的概念。
O	开放封闭原则	开闭原则认为“软件体应该是对于扩展开放的，但是对于修改封闭的”的概念。
L	里氏替换原则	里氏替换原则认为“程序中的对象应该是可以在不改变程序正确性的前提下被它的子类所替换的”的概念。参考 契约式设计。
I	接口隔离原则	接口隔离原则认为“多个特定客户端接口要好于一个宽泛用途的接口”[5] 的概念。
D	依赖反转原则	依赖反转原则认为一个方法应该遵从“依赖于抽象而不是一个实例”[5] 的概念。依赖注入是该原则的一种实现方式。

单一原则

怎么说呢，做人难，做事也难，想要有好有不累，那就只有一心一意啦. so， 这就是单一原则

• 一个程序只做一件事
• 如果功能很复杂就进行拆分

开放封闭原则

作为一个成年人，避免不了需要社会行动。你总能听到别人说多天少说，要多学习新知识，学会整理。我们学习知识就是开放的，但是为了防止遗忘，我们通常回使用自己习惯的记忆方式整理之后记忆，这个是不公开的，只有自己使用，保证自己的有效性和准确性以及完整性

• 对扩展开放，对修改关闭
• 增加需求时，扩展新代码，而非修改已有代码
• 这是软件设计的化境

// 拆分功能
function parseJSON(response) {
  return response.json();
}

function checkStatus(response) {
  if (response.status >= 200 && response.status < 300) {
    return response;
  }

  const error = new Error(response.statusText);
  error.response = response;
  throw error;
}

//  使用
export default function request(url, options) {
  return fetch(url, options)
    .then(checkStatus)
    .then(parseJSON)
    .then(data=>{data})
    .catch(err => ({ err }));
}

L 理氏替换原则

哈哈，出来混，每个人都是有领导的。上级的话我们要听，上级的上级的话我们要听，当上级和上级的上级同时给你安排一个任务的时候，你会听谁的…

• 子类能够覆盖父类，
• 父类出现的地方子类就能出现
• JS使用的比较少

class Person {

  buy () {
    console.log('买东西')
  }
}

class Man extends Person {
  constructor(gender, name) {
    super()
    this.gender = gender
    this.name = name
  }
  buy () {
    console.log('买游戏机')
  }
}

class Women extends Person {
  constructor(gender, name) {
    super()
    this.gender = gender
    this.name = name
  }
  buy () {
    console.log('买包包')
  }
}

let p = new Person()
let m = new Man('男人')
let w = new Women('女人')
// 子类可以覆盖父类
p.buy()
m.buy()
w.buy()

let leo = {
  marry (p:Penson) {
    console.log(`leo 和 ${p.name} 结婚了！`)
  }
}

leo.marry(new Women('女'，'如花'))
leo.marry(new Man('男'，'武大郎'))

接口隔离原则

恩，恩，恩。。。简单，纯粹是很有效的，不过需要自己取舍，太夸张也会很繁琐，，，，，

• 保持接口的单一独立，避免出现胖接口
• JS中没有接口，所以只有在typescipt中时会有体现

// 不同的功能使用定义不同的接口
interface Person {
  fristName: string,
  lastName: string
}

interface Fly{
  fly: boolean
}

function greeting (obj:Person) {
  console.log(`${obj.fristName}${obj.lastName} say hello`)
}

let p = {fristName: 'zhang', lastName: 'san'}
greeting(p)

依赖倒置原则

还记得那碗鸡汤嘛： 不忘初心，方得始终。

怎么说呢： 就是要知道怎么做，为什么要这么做

• 面向接口编程，依赖抽象，而不依赖实现
• 使用方只关注接口而不关注具体类的实现
• JS中使用较少（没有接口，弱类型）