Reaper622
diff --git a/‎.DS_Store
6 KB b/‎.DS_Store
6 KB
diff --git a/‎.gitignore
+2 b/‎.gitignore
+2
diff --git a/‎README.md
+2 b/‎README.md
+2
diff --git a/‎docs/.vuepress/config.js
+14 b/‎docs/.vuepress/config.js
+14
diff --git a/‎docs/Adapter.md
+74 b/‎docs/Adapter.md
+74
diff --git a/‎docs/Appearance.md
+55 b/‎docs/Appearance.md
+55
diff --git a/‎docs/Command.md
+136 b/‎docs/Command.md
+136
@@ -0,0 +1,2 @@
+node_modules
+dp
@@ -1,6 +1,8 @@
 # JavaScript-DesignPatterns
 JavaScript设计模式的相关学习
 
+在线阅读地址: [JavaScript-DesignPatterns](https://reaperlee.cn/dp/)
+
 ## 目录
 ### 创建型
 - [工厂模式](https://github.com/Reaper622/JavaScript-DesignPatterns/blob/master/Factory/Factory.md)
 
@@ -0,0 +1,14 @@
+module.exports = {
+    title: 'JavaScript设计模式',
+    dest: './dp',
+    base: '/dp/',
+    repo: 'https://github.com/Reaper622/JavaScript-DesignPatterns',
+    themeConfig: {
+        // 添加导航栏
+        nav: [
+            {text: '设计模式', link: '/'},
+            {text: '数据结构和算法', link: 'https://reaperlee.cn/ds-al'},
+            {text: '博客', link: 'https://reaperlee.cn'},
+        ]
+    }
+}
@@ -0,0 +1,74 @@
+# 适配器模式
+
+> 适配器模式主要用来解决两个已有接口之间不匹配的问题，它不考虑这些接口是怎么实现的，也不考虑他们将来会如何演化。适配器模式不需要改变当前已有的接口，就能让他们协同作用。
+
+适配器的别名也叫包装器(wrapper)，这是一个并不复杂的模式，在日常开发中有许多这样的场景：例如当我们试图调用某个模块或者某个对象的接口时，却发现这个接口的格式并不符合目前的需求，这时就有两种解决方法，第一种使我们直接修改原来的接口实现，但如果原来的模块或者对象很复杂，亦或是我们拿到的已经是已压缩过的代码，那么去修改原接口就显得不现实了。第二种方法就是我们要讲到的适配器，将原接口转换成你希望拿到的接口，而你只需要通过适配器即可得到，并不需要去修改原模块或对象。
+
+举一个抽象的例子，例如当我们有两台电脑需要充电：
+
+```javascript
+class ThinkPad {
+  charge() {
+    console.log('ThinkPad 开始充电');
+  }
+}
+
+
+class MacBook {
+  charge() {
+    console.log('MacBook 开始充电')
+  }
+}
+// 电源充电
+function PowerToCharge(laptop) {
+  if(laptop.charge instanceof Function) {
+    laptop.charge()
+  }
+}
+
+PowerToCharge(new ThinkPad()) // ThinkPad开始充电
+PowerToCharge(new MacBook()) // MacBook开始充电
+```
+
+但是如果MacBook不能直接用一种电源接口充电，可能我们就需要一种转接器，这里也就使用的适配器模式，我们不能直接更改电脑上的接口，但我们可以通过一层转接（封装），来实现充电
+
+```javascript
+class ThinkPad {
+  charge() {
+    console.log('ThinkPad 开始充电');
+  }
+}
+
+
+class MacBook {
+  type_cCharge() {
+    console.log('MacBook 开始充电')
+  }
+}
+
+// 定义适配器类，来实现对MacBook的转接
+class TypeCToDp {
+  charge() {
+    let macbook = new MacBook();
+    return macbook.type_cCharge()
+  }
+}
+// 电源充电
+function PowerToCharge(laptop) {
+  if(laptop.charge instanceof Function) {
+    laptop.charge()
+  }
+}
+
+PowerToCharge(new ThinkPad()) // ThinkPad开始充电
+PowerToCharge(new TypeCToDp()) // MacBook开始充电
+```
+
+
+
+#### 总结
+
+- 适配器模式虽然是一种相对简单的模式，但适配器在JS或者BFF层使用的场景很多。
+- 但同时，我们要意识到适配器模式其实一种补救措施，它用来解决的是一些古老不可维护或者已经在稳定版本的两个接口不兼容的问题，而在开发初期应该减少或者不使用这种模式，而是要规划好接口的一致性。
+- 适配器不会改变原有的接口，而是一个对象对另一个对象的包装。
+- 适配器模式符合开放封闭原则。
@@ -0,0 +1,55 @@
+# 外观模式
+
+> 外观模式为一组复杂的子系统接口提供一个更高级的统一接口，通过这个接口使得对子系统接口的访问更容易，不符合单一职责原则和开放封闭原则。
+
+其实外观模式很常见，它其实就是通过一个单独的函数，来简化对一个或多个更大型，更为复杂的函数的访问，是一种对复杂操作的封装。
+
+### 封装Ajax
+
+初始化一个原生 Ajax 请求其实是复杂的，我们可以通过封装来简化
+
+```javascript
+function ajaxCall(type, url, callback, data) {
+    let xhr = (function(){
+        try {
+            // 标准方法
+            return new XMLHttpRequest()
+        }catch(e){}
+
+        try {
+            return new ActiveXObject("Msxm12.XMLHTTP")
+        }catch(e){}
+    }())
+    STATE_LOADED = 4
+    STATUS_OK = 200
+
+    // 一但从服务器收到表示成功的相应消息，则执行所给定的回调方法
+    xhr.onreadystatechange = function () {
+        if (xhr.readyState !== STATE_LOADED) {
+            return
+        }
+        if (xhr.state == STATUS_OK) {
+            callback(xhr.responseText)
+        }
+    }
+
+    // 发出请求
+    xhr.open(type.toUpperCase(), url)
+    xhr.send(data)
+}
+```
+
+封装之后，我们发送请求的样子就变成了
+
+```javascript
+// 使用封装的方法
+ajaxCall("get", "/url/data", function(res) {
+    document.write(res)
+})
+```
+
+
+
+#### 总结
+
+	外观模式适用于当需要同时有多个复杂操作时，通过把复杂操作封装，调用时直接用方法调用，提高代码的可阅读性和可维护性。
@@ -0,0 +1,136 @@
+# 命令模式
+
+> 在软件系统里，`行为请求者`与`行为实现者`通常呈现一种*紧耦合*，但在某些场合，比如要对行为进行`记录、撤销/重做、事务`等处理时，这种无法抵御变化的紧耦合是不合适的。在这种情况下，如果要将`行为请求者`与`行为实现者`解耦合，我们需要将一组行为抽象为对象，实现二者之间的松耦合，这就是`命令模式`。
+
+我们需要在命令的发布者和接受者之间定义一个命令对象，命令对象会暴露一个统一的借口给命令的发布者而命令的发布者不需要去了解接受者是如何执行命令的，做到了命令发布者和接受者的解耦合。
+
+[![u06DRP.png](https://s2.ax1x.com/2019/10/03/u06DRP.png)](https://imgchr.com/i/u06DRP)
+
+我们下面的例子中一个页面有三个按钮，每个按钮有不同的功能：
+
+```html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>命令模式</title>
+</head>
+<body>
+    <div>
+        <button id="btn1">Button1</button>
+        <button id="btn2">Button2</button>
+        <button id="btn3">Button3</button>
+    </div>
+    <script src="./Command.js"></script>
+</body>
+</html>
+```
+
+接下来我们定义一个命令发布者（执行者）的类
+
+```javascript
+class Executor {
+    setCommand(btn, command) {
+        btn.onclick = function () {
+            command.execute();
+        }
+    }
+}  
+```
+
+接着我们定义一个命令接受者，此例中为一个菜单
+
+```javascript
+// 定义一个命令接受者
+class Menu {
+    refresh() {
+        console.log('刷新菜单')
+    }
+
+    addSubMenu() {
+        console.log('增加子菜单')
+    }
+
+    deleteMenu() {
+        console.log('删除菜单')
+    }
+}
+```
+
+之后我们将Menu的方法执行封装在单独的类中
+
+```js
+
+class RefreshMenu {
+    constructor(receiver) {
+        // 使命令对象与接受者关联
+        this.receiver = receiver
+    }
+    // 暴露出统一接口给 Excetor
+    execute() {
+        this.receiver.refresh()
+    }
+}
+
+// 定义一个接受子菜单的命令对象的类
+class AddSubMenu {
+    constructor(receiver) {
+        // 使命令对象与接受者关联
+        this.receiver = receiver
+    }
+
+    // 暴露出统一的接口给 Excetor
+    execute() {
+        this.receiver.addSubMenu()
+    }
+}
+
+// 定义一个接受删除菜单对象的类
+class DeleteMenu {
+    constructor(receiver) {
+        this.receiver  = receiver
+    }
+
+    // 暴露出统一的接口给 Excetor
+    execute() {
+        this.receiver.deleteMenu()
+    }
+}
+
+```
+
+之后我们分别实例化不同的对象
+
+```javascript
+// 首先获取按钮对象
+let btn1 = document.getElementById('btn1')
+let btn2 = document.getElementById('btn2')
+let btn3 = document.getElementById('btn3')
+
+let menu = new Menu()
+let executor = new Executor()
+
+let refreshMenu = new RefreshMenu(menu)
+
+// 给 按钮1 添加刷新功能
+executor.setCommand(btn1, refreshMenu) // 点击按钮1 显示"刷新菜单"
+
+let addSubMenu = new AddSubMenu(menu)
+// 给按钮2添加子菜单功能
+executor.setCommand(btn2, addSubMenu)// 点击按钮2 显示"添加子菜单"
+
+let deleteMenu = new DeleteMenu(menu)
+// 给按钮3添加删除功能
+executor.setCommand(btn3, deleteMenu)// 点击按钮3 显示"删除菜单"
+
+```
+
+
+
+#### 总结
+
+- 发布者与接受者实现了解耦合，符合单一职责原则。
+- 命令可扩展，对请求可以进行排队或日志记录，符合开放—封闭原则。
+- 但额外增加了命令对象，存在一定的多余开销。