ts

Author: jarry

decorator-pattern/ts/test/test.ts

@@ -34,7 +34,7 @@ export function test() {
 })()
 /**
 jarry@jarrys-MacBook-Pro ts % sudo npm install -g ts-node
-// direct use ts-node-esm or use tsc before
+// direct use `ts-node-esm` or use `tsc` and `node`
 jarry@jarrys-MacBook-Pro ts % ts-node-esm test/test.ts
 test start:
 Circle::draw()

facade-pattern/java/test/Test.java

@@ -5,6 +5,12 @@
 public class Test {
 
   public static void start() {
+  /**
+   * 外观模式就是在外层添加一个访问接口类，客户通过这统一访问接口来访问这些复杂子类。
+   * 外观模式与适配器模式比较像，都是提供一个高层访问接口，隔绝外部客户与内部子类。
+   * 所不同是外观模式后面的类无需实现相同接口，只是把各种调用整合简化，而适配器需要是同一系列类，为的是解决接口不兼容。
+   * 这里声明外观类，外观类的方法里影藏了很多子类的调用。
+   */
     AbstractFacade facade = new Facade();
     facade.encoding(123456);
     facade.encrypt(999999);

facade-pattern/js/test/test.js

@@ -1,6 +1,12 @@
 import { Facade } from '../src/Facade.js'
 
 export function test() {
+  /**
+   * 外观模式就是在外层添加一个访问接口类，客户通过这统一访问接口来访问这些复杂子类。
+   * 外观模式与适配器模式比较像，都是提供一个高层访问接口，隔绝外部客户与内部子类。
+   * 所不同是外观模式后面的类无需实现相同接口，只是把各种调用整合简化，而适配器需要是同一系列类，为的是解决接口不兼容。
+   * 这里声明外观类，外观类的方法里影藏了很多子类的调用。
+   */
   const facade = new Facade()
   facade.encoding(123456)
   facade.encrypt(999999)

facade-pattern/python/test/test.py

@@ -12,6 +12,13 @@
 from src.Facade import Facade
 
 def test():
+    '''
+    * 外观模式就是在外层添加一个访问接口类，客户通过这统一访问接口来访问这些复杂子类。
+    * 外观模式与适配器模式比较像，都是提供一个高层访问接口，隔绝外部客户与内部子类。
+    * 所不同是外观模式后面的类无需实现相同接口，只是把各种调用整合简化，而适配器需要是同一系列类，为的是解决接口不兼容。
+    * 这里声明外观类，外观类的方法里影藏了很多子类的调用。
+    '''
+
     facade = Facade()
     facade.encoding(123456)
     facade.encrypt(999999)

facade-pattern/ts/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "esm-project",
+  "version": "1.0.0",
+  "main": "test/test.js",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "type": "module"
+}

facade-pattern/ts/src/AbstractFacade.ts

@@ -0,0 +1,6 @@
+// 外观模式的接口或抽象类，可选
+export interface AbstractFacade {
+  encoding(id: number): void
+
+  encrypt(id: number): void
+}

facade-pattern/ts/src/EncodeModule.ts

@@ -0,0 +1,6 @@
+// 编码模块
+export class EncodeModule {
+  encoding() {
+    console.log(this.constructor.name + '::encoding() 进行编码处理。')
+  }
+}

facade-pattern/ts/src/Facade.ts

@@ -0,0 +1,42 @@
+import { AbstractFacade } from './AbstractFacade.js'
+import { FileModule } from './FileModule.js'
+import { NetworkModule } from './NetworkModule.js'
+import { EncodeModule } from './EncodeModule.js'
+
+// 外观模式实现类，是外部调用与内部子系统的衔接层
+export class Facade implements AbstractFacade {
+  fileModule: FileModule
+  networkModule: NetworkModule
+  encodeModule: EncodeModule
+  constructor() {
+    this.fileModule = new FileModule()
+    this.networkModule = new NetworkModule()
+    this.encodeModule = new EncodeModule()
+  }
+
+  encoding(id: number) {
+    console.log(this.constructor.name + '::encoding() [id=' + id + ']')
+    this.networkModule.request()
+    this.fileModule.readFile()
+    this.encodeModule.encoding()
+    this.fileModule.saveFile()
+  }
+
+  encrypt(id: number) {
+    console.log(this.constructor.name + '::encrypt() [id=' + id + ']')
+    this.fileModule.readFile()
+    this.encodeModule.encoding()
+  }
+
+  getFileModule() {
+    return this.fileModule
+  }
+
+  getNetworkModule() {
+    return this.networkModule
+  }
+
+  getEncodeModule() {
+    return this.encodeModule
+  }
+}

facade-pattern/ts/src/FileModule.ts

@@ -0,0 +1,10 @@
+// 文件模块
+export class FileModule {
+  readFile() {
+    console.log(this.constructor.name + '::readFile() 读取文件。')
+  }
+
+  saveFile() {
+    console.log(this.constructor.name + '::saveFile() 保存文件。')
+  }
+}

facade-pattern/ts/src/NetworkModule.ts

@@ -0,0 +1,6 @@
+// 网络模块
+export class NetworkModule {
+  request() {
+    console.log(this.constructor.name + '::request() 远程读取。')
+  }
+}

facade-pattern/ts/test/test.html

@@ -0,0 +1,5 @@
+<script type="module">
+// module need run in http server
+import { test } from './test.js'
+alert('pls look console info.' + '\n\r' + test)
+</script>

facade-pattern/ts/test/test.ts

@@ -0,0 +1,34 @@
+import { Facade } from '../src/Facade.js'
+
+export function test() {
+  /**
+   * 外观模式就是在外层添加一个访问接口类，客户通过这统一访问接口来访问这些复杂子类。
+   * 外观模式与适配器模式比较像，都是提供一个高层访问接口，隔绝外部客户与内部子类。
+   * 所不同是外观模式后面的类无需实现相同接口，只是把各种调用整合简化，而适配器需要是同一系列类，为的是解决接口不兼容。
+   * 这里声明外观类，外观类的方法里影藏了很多子类的调用。
+   */
+  const facade = new Facade()
+  facade.encoding(123456)
+  facade.encrypt(999999)
+}
+
+// 执行测试
+;(function () {
+  console.log('test start:')
+  test()
+})()
+
+/**
+jarry@jarrys-MacBook-Pro ts % sudo npm install -g ts-node
+// direct use `ts-node-esm` or use `tsc` and `node`
+jarry@jarrys-MacBook-Pro ts % ts-node-esm test/test.ts
+test start:
+Facade::encoding() [id=123456]
+NetworkModule::request() 远程读取。
+FileModule::readFile() 读取文件。
+EncodeModule::encoding() 进行编码处理。
+FileModule::saveFile() 保存文件。
+Facade::encrypt() [id=999999]
+FileModule::readFile() 读取文件。
+EncodeModule::encoding() 进行编码处理。
+*/

facade-pattern/ts/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "lib": ["esnext", "dom"],
+    "module": "esnext",
+    "strict": true,
+    "removeComments": true,
+    "forceConsistentCasingInFileNames": true,
+    "strictPropertyInitialization": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+  },
+  "include": [
+    "src/**/*.ts",
+    "test/*.ts",
+  ]
+}

factory-pattern/java/test/Test.java

@@ -5,6 +5,10 @@
 public class Test {
 
   public static void start() {
+    /**
+     * 工厂模式由工厂类提供统一的创建对象的方法，省去直接new，而是通过统一方法来创建。
+     * 这样的好处就是让对象创建和调用解耦，便于在创建对象时统一干预。
+     */
     VehicleFactory vehicleFactory = new VehicleFactory();
 
     // 获取Bus对象，并调用它的 run 方法
@@ -14,19 +18,20 @@ public static void start() {
     // 获取Car对象，并调用它的 run 方法
     Vehicle car = vehicleFactory.getVehicle(VehicleType.CAR);
     // 类型转为Car
-    Car car1 = (Car)car;
+    Car car1 = (Car) car;
     car1.run();
 
     // 获取Motorcycle对象，并调用它的 run 方法
     // 类型直接转为Motorcycle
-    Motorcycle motorcycle = (Motorcycle)vehicleFactory.getVehicle(VehicleType.MOTORCYCLE);
+    Motorcycle motorcycle = (Motorcycle) vehicleFactory.getVehicle(VehicleType.MOTORCYCLE);
     motorcycle.run();
 
     // 获取Motorcycle对象，并调用它的 run 方法
     Vehicle van = vehicleFactory.getVehicle(VehicleType.VAN);
     van.run();
 
   }
+
   public static void main(String[] args) {
     System.out.println("test start:");
     start();
@@ -36,16 +41,16 @@ public static void main(String[] args) {
 
 /**
  * 测试
-jarry@jarrys-MacBook-Pro java % java --version
-java 14.0.1 2020-04-14
-Java(TM) SE Runtime Environment (build 14.0.1+7)
-Java HotSpot(TM) 64-Bit Server VM (build 14.0.1+7, mixed mode, sharing)
-
-jarry@jarrys-MacBook-Pro java % javac test/Test.java 
-jarry@jarrys-MacBook-Pro java % java test/Test 
-test start:
-Bus::run().
-Car::run().
-Motorcycle::run().
-Van::run().
+ * jarry@jarrys-MacBook-Pro java % java --version
+ * java 14.0.1 2020-04-14
+ * Java(TM) SE Runtime Environment (build 14.0.1+7)
+ * Java HotSpot(TM) 64-Bit Server VM (build 14.0.1+7, mixed mode, sharing)
+ * 
+ * jarry@jarrys-MacBook-Pro java % javac test/Test.java
+ * jarry@jarrys-MacBook-Pro java % java test/Test
+ * test start:
+ * Bus::run().
+ * Car::run().
+ * Motorcycle::run().
+ * Van::run().
  */

factory-pattern/js/test/test.js

@@ -1,6 +1,10 @@
 import { VehicleFactory, VehicleType } from '../src/VehicleFactory.js'
 
 export function test() {
+  /**
+   * 工厂模式由工厂类提供统一的创建对象的方法，省去直接new，而是通过统一方法来创建。
+   * 这样的好处就是让对象创建和调用解耦，便于在创建对象时统一干预。
+   */
   const vehicleFactory = new VehicleFactory()
 
   // 获取Bus对象，并调用它的 run 方法

factory-pattern/python/test/test.py

@@ -11,6 +11,10 @@
 from src.VehicleFactory import VehicleType
 
 def test():
+  '''
+   * 工厂模式由工厂类提供统一的创建对象的方法，省去直接new，而是通过统一方法来创建。
+   * 这样的好处就是让对象创建和调用解耦，便于在创建对象时统一干预。
+  '''
   vehicle_factory = VehicleFactory()
 
   # 获取Bus对象，并调用它的 run 方法

factory-pattern/ts/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "esm-project",
+  "version": "1.0.0",
+  "main": "test/test.js",
+  "scripts": {
+    "test": "node test/test.js"
+  },
+  "type": "module"
+}

factory-pattern/ts/src/Bus.ts

@@ -0,0 +1,7 @@
+import { Vehicle } from './Vehicle.js'
+export class Bus implements Vehicle {
+  constructor(options: object) {}
+  run() {
+    console.log('Bus::run().')
+  }
+}

factory-pattern/ts/src/Car.ts

@@ -0,0 +1,7 @@
+import { Vehicle } from './Vehicle.js'
+export class Car implements Vehicle {
+  constructor(options: object) {}
+  run() {
+    console.log('Car::run().')
+  }
+}

factory-pattern/ts/src/Motorcycle.ts

@@ -0,0 +1,7 @@
+import { Vehicle } from './Vehicle.js'
+export class Motorcycle implements Vehicle {
+  constructor(options: object) {}
+  run() {
+    console.log('Motorcycle::run().')
+  }
+}

factory-pattern/ts/src/Van.ts

@@ -0,0 +1,7 @@
+import { Vehicle } from './Vehicle.js'
+export class Van implements Vehicle {
+  constructor(options: object) {}
+  run() {
+    console.log('Van::run().')
+  }
+}

factory-pattern/ts/src/Vehicle.ts

@@ -0,0 +1,3 @@
+export interface Vehicle {
+  run(): void
+}

factory-pattern/ts/src/VehicleFactory.ts

@@ -0,0 +1,27 @@
+import { Bus } from './Bus.js'
+import { Car } from './Car.js'
+import { Motorcycle } from './Motorcycle.js'
+import { Van } from './Van.js'
+import { Vehicle } from './Vehicle.js'
+export const VehicleType = {
+  BUS: 'bus',
+  CAR: 'car',
+  MOTORCYCLE: 'motorcycle',
+  VAN: 'van'
+}
+export class VehicleFactory {
+  getVehicle(type: string, options: object = {}): Vehicle {
+    switch (type) {
+      case 'bus':
+        return new Bus(options)
+      case 'car':
+        return new Car(options)
+      case 'motorcycle':
+        return new Motorcycle(options)
+      case 'van':
+        return new Van(options)
+      default:
+        return new Bus(options)
+    }
+  }
+}

factory-pattern/ts/test/test.html

@@ -0,0 +1,5 @@
+<script type="module">
+// module need run in http server
+import { test } from './test.js'
+alert('pls look console info.' + '\n\r' + test)
+</script>