JavaScript设计模式经典-面向对象中六大原则

做者 | Jeskson来源 | 达达前端小酒馆

1

主要学习JavaScript中的六大原则。那么六大原则还记得是什么了吗？六大原则指：单一职责原则（SRP）,开放封闭原则（OCP）,里氏替换原则（LSP）,依赖倒置原则（DIP）,接口分离原则（ISP）,最少知识原则（LKP）。

单一职责原则开放封闭原则里氏替换原则依赖倒置原则接口分离原则最少知识原则

那么什么是单一职责原则呢？单一职责原则，英文单词为：single responsable princple，原则体现为，一个对象或者是方法只作一件事。

从前车马很慢，书信很远，一辈子只够爱一我的。“从前的日色变得慢，车，马，邮件都慢，一辈子只够爱一我的 从前的锁也好看，钥匙精美有样子，你锁了，人家就懂了”（一个对象或者是方法只作一件事情）

若是一个方法承担了不少不少的职责，那么它在需求发生变化的过程当中，须要改写这个方法的可能性就很大。

单一职责原则，一个类只提供一种功能，不要存在过多致使类变化的缘由。从前，一我的负责两个不一样的任务，为任务1，任务2，当任务1须要作调整时，而须要这我的作修整时，有可能会影响任务2的正常运行，会致使任务2没有办法完成。

遵循单一职责原则，就能够解决这种状况的发生，分别让两我的分别作任务1，任务2，让人1作任务1，让人2作任务2，这样，当须要改变任务1时，不会影响到任务2的正常运行，同理，任务2须要作修改时，人1作的事也不会发生影响。

里氏替换原则：全部引用基类的地方必须可以使用其子类的对象，从前有一个游戏玩家A，它有一个招式Z1，如今把这个招式Z1进行扩展，扩展后成为大招Z，其大招Z由原来的招式Z1和新功能Z2组成，新功能Z又由游戏玩家A的子类徒弟游戏玩家B去完成，那么这个子类徒弟游戏玩家B在完成这个新功能Z2的同时，有可能会影响到原来的招式Z1，而致使招式发生错误。

（迪米特法则：只与直接的朋友通讯），每一个对象都会和其余对象有耦合的关系，只要两个对象之间有耦合关系，就说这两个对象之间是朋友关系。

2

开放封闭原则，类，方法等应当对其扩展开放，对其修改封闭，在不修改的前提下进行扩展，扩展开发，当有新的需求出现的时候，咱们能够对其进行扩展示有的方法，对象等已到达目的；修改关闭，不能对实体进行任何的修改。

不修改现有的功能方法，就能够进行实现各类变化的代码。

// 定义一个方法
function da(x, y) {
 document.getElementById(x).style.color = y;
}

// 调用方法da
da('dashucoding', 'red');

// 开发封闭原则 -> 错误
// 定义方法
function da(x, y, z) {
 document.getElementById(x).style.color = y;
 document.getElementById(x).style.size = z;
}

// 调用方法da
da('dashucoding', 'red', '100px');

// 定义一个方法
function da(x, y) {
 document.getElementById(x).style.color = y;
}

// 不去动da这个方法
function dada(x, y, z) {
 da(x,y);
 document.getElementById(x).style.size = z;
}

// 正确使用开发封闭原则

function da(x, y) {
 document.getElementById(x).style.color = y;
}

da('dashucoding', 'red');

function dada(x, y, z) {
 da(x,y);
 document.getElementById(x).style.size = z;
}

dada('dashucoding', 'red', '100px');

单一职责原则，简介，就一个类而言，应该仅有一个引发它变化的缘由。

开放封闭原则，简介，软件实体对扩展是开放的，但对修改是关闭的。即在不修改一个软件实体的基础上去扩展其功能。

里氏替换原则，简介，子类必须可以替换它们的基类。

依赖倒置原则，简介，高层次的模块不该该依赖于低层次的模块，他们都应该依赖于抽象。抽象不该该依赖于具体实现，具体实现应该依赖于抽象。做用，下降了客户与实现模块间的耦合。

接口分离原则，简介，使用多个专门的接口来取代一个统一的接口。

合成复用原则，简介，就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象经过向这些对象的委派达到复用已有功能的目的。简单来讲就是，要尽可能使用组合，尽可能不要使用继承。

迪米特法则，简介，又叫作最少知识原则，就是说一个对象应当对其余对象有尽量少的了解，不和陌生人说话。

3

里氏替换原则，就是对开发封闭原则进行补充，讲的是基类和子类的关系。理解里氏替换原则的最经典的例子是“正方形是长方形”，“鸵鸟不是鸟”等，拿正方形来讲，上数学课的时候，咱们就知道，正方形是长方形，它是一个长宽相等的长方形，那么由此能够看出，应该让正方形继承自长方形。

public class Rectangle {
 private int height;
 private int width;
 
 // 省略getter setter
}

// 正方形长和宽始终同样 覆写
public class Square extends Rectangle {
 @Override
 public void setWidth(int width) {
  super.setWidth(width);
  super.setHeight(width);
 }
 
 @Override
 public void setHeight(int height) {
  super.setWidth(height);
  super.setHeight(height);
 }
}

public class Test {
 public static void main(String[] args) {
  Test test = new Test();
   Rectangle rectangle = new Rectangle();
   rectangle.setHeight(5);
   rectangle.setWidth(4);
   test.zoom(rectangle, 2, 3);
   
   Square square = new Square();
   square.setHeight(5);
   square.setWidth(4);
   test.zoom(square, 2, 3);
 }
 
 public void zoom(Rectangle rectangle, int width, int height) {
  rectangle.setWidth(rectangle.getWidth()   width);
  rectangle.setHeight(rectangle.getHeight()   height);
 }
}

依赖倒置原则，高层次的模块不该该依赖于低层次的模块，它们都应该依赖于抽象。抽象不该该依赖于具体实现，具体实现应该依赖于抽象。

高层次模块依赖方向中层次模块，中层次模块依赖于低层次模块。高层次与低层次不相互依赖，低层次的任何修改都会影响高层次的模块。抽象层，高级层次，实现层次，具体实现依赖抽象层。

接口分离原则，客户端不该该依赖它不须要的接口，一个类对另外一个类的依赖应该创建在最小的接口上。怎么说呢？

有三个客户端A,B,C都依赖于一个大的接口，这个大的接口有A(),B(),C()，可是客户端A只须要A()而已，其余不须要，这个时候就利用接口分离原则让客户端A只须要A(),让客户端B只须要B(),让客户端C只须要C()。

设计原则是指导思想，从思想上给咱们指明程序设计的正确方向，设计模式是实现的手段，所以设计模式也是遵照这些原则的。达到高内聚低耦合，高内聚就是说模块内部要高度聚合，是模块内部的关系，低耦合是说模块与模块之间的耦合度要尽可能低，是模块与模块之间的关系。

单一职责原则总结：一个对象只作一件事。

开放封闭原则总结：对扩展开放，对修改封闭。

迪米特法则，又叫作最少知识原则总结：一个对象应该对其余对象有最少的了解。

设计模式中的外观模式和中介模式，是迪米特法则应用的例子。

迪米特法简单就是，只与朋友说话，不与陌生人说话。缺点就是系统中会产生大量的小方法。

合成复用原则，多用组合，少用继承。继承是面向对象的三大特征，封装，继承，多态，继承实现简单，易于扩展，可是继承也是由缺陷的，父类变，子类必须变，继承破坏了封装，对父类来讲，它的实现对子类来讲是透明的，继承是一种强耦合的关系。

父类变，子类必须变；继承破坏了封装（子类是封装的，因父类的改变，致使父类破坏了子类的封装），对于子类来讲，经过继承父类，是没有安全保障的，父类修改其内容，就会致使子类的功能被破坏；对于父类来讲，子类继承父类，重写它的方法时，父类的方法是不能够任意修改的。

设计原则：

单一职责原则，一个方法只作一件事情；里氏替换原则，子类能够代替父类；依赖倒置原则，只依赖接口不依赖方法，不关心底层的实现方法；接口分离原则，把大的接口拆分红小的接口；迪米特法则，函数中传入的参数越少越好，开放封闭原则，面向扩展开放，面向修改关闭。

5

单一职责原则，优势：下降了单个类或者是对象的复杂程度，按照单一职责原则把对象分解成更小的单位，有利于代码的复用，也有利于进行单元测试，当一个职责须要改变的时候，不会影响到其余的职责。缺点：增长了编码的复杂程度，同时增长了对象之间的关联难度。

理解为不一样类具有不一样的职责。一个类只承担一个职责。

最少知识原则，优势：减小或消除对象之间耦合程度，提升复用性。缺点：须要封装对象或者是引入一个第三方对象来处理二者之间的关系，有时候第三方对象会很复杂，复杂到难以维护。

开放封闭原则，优势：程序的稳定性很高，容易变动的地方分离后更加容易维护。

// 单一职责原则
// 类
public class People {
 public void work() {
  System.out.println("work");
 }
 public void eat() {
  System.out.println("eat");
 }
 public void play() {
  System.out.println("play");
 }
}
// 一个类， 三个职责
// 单一职责原则
public interface workInter {
 public void work();
}
public interface eatInter {
 public void eat();
}
public interface playInter {
 public void play();
}
// 继承接口
public class People implements workInter, eatInter, playInter {
 public void work() {
  System.out.println("work");
 }
 public void eat() {
  System.out.println("eat");
 }
 public void play() {
  System.out.println("play");
 }
}

public class Test {
 public static void main(String args[]) {
  People people = new People();
  workInter worker = new People();
  worker.work();
  
  eatInter eater = new People();
  eater.eat();
  
  playInter player = new People();
  player.play();
 }
}

里氏替换原则，全部引用基类的地方必须能透明地使用其子类的对象，子类必须彻底实现父类的功能，凡是父类出现的地方，替换成子类也不会有问题。

里氏替换原则，我喜欢动物，那我必定喜欢狗，因狗是动物的子类；可是我说我喜欢狗，不能说我喜欢动物，由于我不喜欢其余小小小型动物。

子类必须彻底实现父类的功能，举例没有实现的：

// 父类
public abstract class Father {
 // work
 public abstract void work();
}
// 子类
public class Child extends Father {
 @Override
 public void work() {
  // 实现了这个方法，但功能不实现，什么都不作
 }
}

依赖倒置原则，理解为使用接口或者是抽象类。模块之间的依赖是经过抽象发生的，实现类之间不能直接的依赖的关系，实现类的依赖关系是经过接口或者抽象类产生的，接口或者抽象类依赖于实现类，实现类要依赖于接口或者是抽象类。

public class Da {
 private Dada dada = null;
 public Da(Dada dada) {
  this.da = da;
 }
}

public interface DaInter {
 public void setDa(Dada dada);
}

public class Da implements DaInter {
 private Dada dada = null;
 public void setDA(Dada dada) {
  this.da = da;
 }
}

接口分离原则，若是一个类实现一个接口，可是这个接口有它不要的方法，就须要把这个接口拆分，把它须要的方法独立出来造成一个新的接口给这个类去实现。

单例模式：一个类只有一个实例，用一个变量去区别当前实例是否建立过

// 一个参数，一个变量
var da = function (name) {
 this.name = name;
 this.instance = null;
}
da.prototype.getName = function() {
 alert(this.name)
}
da.getInstance = fucntion(name) {
 if(!this.instance) {
  this.instance = da(name);
 }
 return this.instance;
}

推荐阅读

一、你知道多少this，new，bind，call，apply？那我告诉你

二、为何学习JavaScript设计模式，由于它是核心

三、一篇文章把你带入到JavaScript中的闭包与高级函数

四、大厂HR面试ES6中的深刻浅出面试题知识点

五、一篇JavaScript技术栈带你了解继承和原型链

关于目前文章内容即涉及前端，PHP知识点，若是有兴趣便可关注，很荣幸，能被您发现，真是慧眼识英！也感谢您的关注，在将来的日子里，但愿可以一直默默的支持我，我也会努力写出更多优秀的做品。咱们一块儿成长，从零基础学编程，将 Web前端领域、数据结构与算法、网络原理等通俗易懂的呈现给小伙伴。分享 Web 前端相关的技术文章、工具资源、精选课程、热点资讯。

若本号内容有作得不到位的地方（好比：涉及版权或其余问题），请及时联系咱们进行整改便可，会在第一时间进行处理。

请点赞！由于大家的赞同/鼓励是我写做的最大动力！

欢迎关注达达的CSDN！

这是一个有质量，有态度的博客