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！

這是一個有質量，有態度的博客