JavaScript的7种设计模式

 当启动一个新的项目时候，我们不应该马上开始编程。而是首先应该定义项目的目的和范围，然后列出其功能或规格。如果你已经开始编程或者正在从事一个复杂的项目，则应该选择一个最适合你项目的设计模式。

成都创新互联是一家专业提供海宁企业网站建设,专注与成都网站建设、成都网站制作、H5技术、小程序制作等业务。10年已为海宁众多企业、政府机构等服务。创新互联专业网站制作公司优惠进行中。

什么是设计模式?

在软件工程中，设计模式是针对软件设计中常见问题的可重用解决方案。设计模式也是经验丰富的开发人员针对特定问题的最佳实践。它可以被当作编程的模板。

为什么要使用设计模式?

许多工程师要么认为设计模式浪费时间，要么不知道如何恰当的使用设计模式。但如果能正确使用设计模式，则可以帮助你写出更好的可读性更高的代码，并且代码更容易被维护和理解。

最重要的是，设计模式为软件开发人员提供了通用的词汇表。它们能让学习你代码的人很快了解代码的意图。例如，如果你的项目中使用了装饰器模式，那么新的开发可以很快就知道这段代码的作用，从而他们可以将更多精力放在解决业务问题上，而不是试图理解代码在做什么。

我们已经知道了什么是设计模式和它的重要性，下面我们深入研究一下 JavaScript 中的 7 种设计模式。

一、模块模式

模块是一段独立的代码，因此我们可以更新模块而不会影响代码的其它部分。模块还允许我们通过为变量创建单独的作用域来避免命名空间污染。当它们与其它代码解耦时，我们还可以在其它项目中重用模块。

模块是任何现代 JavaScript 应用程序不可或缺的一部分，有助于保持代码干净，独立和有条理。在 JavaScript 中有许多方法可以创建模块，其中一种是模块模式。

与其它编程语言不同，JavaScript 没有访问修饰符，也就是说，你不能将变量声明为私有的或公共的。因此，模块模式也可用来模拟封装的概念。

模块模式使用 IIFE(立即调用的函数表达式)，闭包和函数作用域来模拟封装的概念。例如：

 
 
 
    
  
  
  
  1. const myModule = (function() {   
    2. 
  
  
  
  2.   const privateVariable = 'Hello World';   
    3. 
  
  
  
  3.   function privateMethod() { 
    4. 
  
  
  
  4.     console.log(privateVariable); 
    5. 
  
  
  
  5.   } 
    6. 
  
  
  
  6.   return { 
    7. 
  
  
  
  7.     publicMethod: function() { 
    8. 
  
  
  
  8.       privateMethod(); 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10.   } 
    11. 
  
  
  
  11. })(); 
    12. 
  
  
  
  12. myModule.publicMethod(); 
    13.

由于是 IIFE 因此代码会被立即执行，并将返回对象赋值给了 myModule 变量。由于闭包，即使在 IIFE 完成后，返回的对象仍可以访问 IIFE 内部定义的函数和变量。

因此，IIFE 内部定义的变量和函数对外部是看不见的，从而使其成为 myModule 模块的私有成员。

执行代码后，myModule 变量看起来像下面所示：

 
 
 
    
  
  
  
  1. const myModule = { 
    2. 
  
  
  
  2.   publicMethod: function() { 
    3. 
  
  
  
  3.     privateMethod(); 
    4. 
  
  
  
  4.   }}; 
    5.

因此当我们调用 publicMethod() 时候，它将调用 privateMethod() 例如：

 
 
 
    
  
  
  
  1. // Prints 'Hello World' 
    2. 
  
  
  
  2. module.publicMethod(); 
    3.

二、揭示模块模式

揭示模块模式是 Christian Heilmann 对模块模式的略微改进。模块模式的问题在于，我们必须创建新的公共函数才能调用私有函数和变量。

在这种模式下，我们将返回的对象的属性映射到要公开暴露的私有函数上。这就是为什么将其称为揭示模块模式。例如：

 
 
 
    
  
  
  
  1. const myRevealingModule = (function() {   
    2. 
  
  
  
  2.   let privateVar = 'Peter'; 
    3. 
  
  
  
  3.   const publicVar  = 'Hello World'; 
    4. 
  
  
  
  4.   function privateFunction() { 
    5. 
  
  
  
  5.     console.log('Name: '+ privateVar); 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7.    
    8. 
  
  
  
  8.   function publicSetName(name) { 
    9. 
  
  
  
  9.     privateVar = name; 
    10. 
  
  
  
  10.   } 
    11. 
  
  
  
  11.   function publicGetName() { 
    12. 
  
  
  
  12.     privateFunction(); 
    13. 
  
  
  
  13.   } 
    14. 
  
  
  
  14.   /** reveal methods and variables by assigning them to object     properties */ 
    15. 
  
  
  
  15. return { 
    16. 
  
  
  
  16.     setName: publicSetName, 
    17. 
  
  
  
  17.     greeting: publicVar, 
    18. 
  
  
  
  18.     getName: publicGetName 
    19. 
  
  
  
  19.   }; 
    20. 
  
  
  
  20. })(); 
    21. 
  
  
  
  21. myRevealingModule.setName('Mark'); 
    22. 
  
  
  
  22. // prints Name: Mark 
    23. 
  
  
  
  23. myRevealingModule.getName(); 
    24.

这种模式让我们更容易知道哪些函数和变量是公共的，无形中提高了代码的可读性。执行代码后 myRevealingModule 看起来像下所示：

 
 
 
    
  
  
  
  1. const myRevealingModule = { 
    2. 
  
  
  
  2.   setName: publicSetName, 
    3. 
  
  
  
  3.   greeting: publicVar, 
    4. 
  
  
  
  4.   getName: publicGetName 
    5. 
  
  
  
  5. }; 
    6.

当我们调用 myRevealingModule.setName('Mark') 时，实际调用了内部的 publicSetName。当调用 myRevealingModule.getName() 时，实际调用了内部的 publicGetName 例如：

 
 
 
    
  
  
  
  1. myRevealingModule.setName('Mark'); 
    2. 
  
  
  
  2. // prints Name: Mark 
    3. 
  
  
  
  3. myRevealingModule.getName(); 
    4.

与模块模式相比，揭示模块模式的优势有：

  • 通过修改 return 语句中的一行，我们可以将成员从公共变为为私人，反之亦然。
  • 返回的对象不包含任何函数定义，所有右侧表达式都在 IIFE 中定义，从而使代码清晰易读。

三、ES6 模块

在 ES6 之前，JavaScript 没有内置模块，因此开发人员必须依靠第三方库或模块模式来实现模块。但是自从 ES6，JavaScript 内置了模块。

ES6 的模块是以文件形式存储的。每个文件只能有一个模块。默认情况下，模块内的所有内容都是私有的。通过使用 export 关键字来暴露函数、变量和类。模块内的代码始终在严格模式下运行。

3.1 导出模块

有两种方法可以导出函数和变量声明：

  • 在函数和变量声明的前面添加 export 关键字。例如：

 

 
 
 
    
  
  
  
  1. // utils.js 
    2. 
  
  
  
  2. export const greeting = 'Hello World'; 
    3. 
  
  
  
  3. export function sum(num1, num2) { 
    4. 
  
  
  
  4.   console.log('Sum:', num1, num2); 
    5. 
  
  
  
  5.   return num1 + num2; 
    6. 
  
  
  
  6. } 
    7. 
  
  
  
  7. export function subtract(num1, num2) { 
    8. 
  
  
  
  8.   console.log('Subtract:', num1, num2); 
    9. 
  
  
  
  9.   return num1 - num2; 
    10. 
  
  
  
  10. } 
    11. 
  
  
  
  11. // This is a private function 
    12. 
  
  
  
  12. function privateLog() { 
    13. 
  
  
  
  13.   console.log('Private Function'); 
    14. 
  
  
  
  14. } 
    15.
  • 在代码的最后添加 export 关键字来暴露函数和变量。例如：

 

 
 
 
    
  
  
  
  1. // utils.js 
    2. 
  
  
  
  2. function multiply(num1, num2) { 
    3. 
  
  
  
  3.   console.log('Multiply:', num1, num2); 
    4. 
  
  
  
  4.   return num1 * num2; 
    5. 
  
  
  
  5. } 
    6. 
  
  
  
  6. function divide(num1, num2) { 
    7. 
  
  
  
  7.   console.log('Divide:', num1, num2); 
    8. 
  
  
  
  8.   return num1 / num2; 
    9. 
  
  
  
  9. } 
    10. 
  
  
  
  10. // This is a private function 
    11. 
  
  
  
  11. function privateLog() { 
    12. 
  
  
  
  12.   console.log('Private Function'); 
    13. 
  
  
  
  13. } 
    14. 
  
  
  
  14. export {multiply, divide}; 
    15.

3.2 导入模块

与导出模块相似，有两种使用 import 关键字导入模块的方法。例如：

  • 一次导入多个项目

 

 
 
 
    
  
  
  
  1. // main.js 
    2. 
  
  
  
  2. // importing multiple items 
    3. 
  
  
  
  3. import { sum, multiply } from './utils.js'; 
    4. 
  
  
  
  4. console.log(sum(3, 7)); 
    5. 
  
  
  
  5. console.log(multiply(3, 7)); 
    6.
  • 导入所有模块

 

 
 
 
    
  
  
  
  1. // main.js 
    2. 
  
  
  
  2. // importing all of module 
    3. 
  
  
  
  3. import * as utils from './utils.js'; 
    4. 
  
  
  
  4. console.log(utils.sum(3, 7)); 
    5. 
  
  
  
  5. console.log(utils.multiply(3, 7)); 
    6.

3.3 导入导出中使用别名

  • 重命名导出

 

 
 
 
    
  
  
  
  1. // utils.js 
    2. 
  
  
  
  2. function sum(num1, num2) { 
    3. 
  
  
  
  3.   console.log('Sum:', num1, num2); 
    4. 
  
  
  
  4.   return num1 + num2; 
    5. 
  
  
  
  5. } 
    6. 
  
  
  
  6. function multiply(num1, num2) { 
    7. 
  
  
  
  7.   console.log('Multiply:', num1, num2); 
    8. 
  
  
  
  8.   return num1 * num2; 
    9. 
  
  
  
  9. } 
    10. 
  
  
  
  10. export {sum as add, multiply}; 
    11.
  • 重命名导入

 

 
 
 
    
  
  
  
  1. // main.js 
    2. 
  
  
  
  2. import { add, multiply as mult } from './utils.js'; 
    3. 
  
  
  
  3. console.log(add(3, 7)); 
    4. 
  
  
  
  4. console.log(mult(3, 7)); 
    5.

四、单例模式

一个单例对象是只能实例化一次的对象。如果不存在，则单例模式将创建类的新实例。如果存在实例，则仅返回对该对象的引用。重复调用构造函数将始终获取同一对象。

JavaScript 是一直内置单例的语言。我们只是不称它们为单例，我们称它们为对象字面量。例如：

 
 
 
    
  
  
  
  1. const user = { 
    2. 
  
  
  
  2.   name: 'Peter', 
    3. 
  
  
  
  3.   age: 25, 
    4. 
  
  
  
  4.   job: 'Teacher', 
    5. 
  
  
  
  5.   greet: function() { 
    6. 
  
  
  
  6.     console.log('Hello!'); 
    7. 
  
  
  
  7.   } 
    8. 
  
  
  
  8. }; 
    9.

因为 JavaScript 中的每个对象都占用一个唯一的内存位置，并且当我们调用该 user 对象时，实际上是在返回该对象的引用。

如果我们尝试将 user 变量复制到另一个变量并修改该变量。例如：

 
 
 
    
  
  
  
  1. const user1 = user; 
    2. 
  
  
  
  2. user1.name = 'Mark'; 
    3.

我们将看到两个对象都被修改，因为 JavaScript 中的对象是通过引用而不是通过值传递的。因此，内存中只有一个对象。例如：

 
 
 
    
  
  
  
  1. // prints 'Mark' 
    2. 
  
  
  
  2. console.log(user.name); 
    3. 
  
  
  
  3. // prints 'Mark' 
    4. 
  
  
  
  4. console.log(user1.name); 
    5. 
  
  
  
  5. // prints true 
    6. 
  
  
  
  6. console.log(user === user1); 
    7.

可以使用构造函数来实现单例模式。例如：

 
 
 
    
  
  
  
  1. let instance = null; 
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. function User() { 
    4. 
  
  
  
  4.   if(instance) { 
    5. 
  
  
  
  5.     return instance; 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7.   instance = this; 
    8. 
  
  
  
  8.   this.name = 'Peter'; 
    9. 
  
  
  
  9.   this.age = 25; 
    10. 
  
  
  
  10.    
    11. 
  
  
  
  11.   return instance; 
    12. 
  
  
  
  12. } 
    13. 
  
  
  
  13. const user1 = new User(); 
    14. 
  
  
  
  14. const user2 = new User(); 
    15. 
  
  
  
  15. // prints true 
    16. 
  
  
  
  16. console.log(user1 === user2); 
    17.

调用此构造函数时，它将检查 instance 对象是否存在。如果对象不存在，则将 this 变量分配给 instance 变量。如果该对象存在，则只返回该对象。

单例也可以使用模块模式来实现。例如：

 
 
 
    
  
  
  
  1. const singleton = (function() { 
    2. 
  
  
  
  2.   let instance; 
    3. 
  
  
  
  3.    
    4. 
  
  
  
  4.   function init() { 
    5. 
  
  
  
  5.     return { 
    6. 
  
  
  
  6.       name: 'Peter', 
    7. 
  
  
  
  7.       age: 24, 
    8. 
  
  
  
  8.     }; 
    9. 
  
  
  
  9.   } 
    10. 
  
  
  
  10.   return { 
    11. 
  
  
  
  11.     getInstance: function() { 
    12. 
  
  
  
  12.       if(!instance) { 
    13. 
  
  
  
  13.         instance = init(); 
    14. 
  
  
  
  14.       } 
    15. 
  
  
  
  15.        
    16. 
  
  
  
  16.       return instance; 
    17. 
  
  
  
  17.     } 
    18. 
  
  
  
  18.   } 
    19. 
  
  
  
  19. })(); 
    20. 
  
  
  
  20. const instanceA = singleton.getInstance(); 
    21. 
  
  
  
  21. const instanceB = singleton.getInstance(); 
    22. 
  
  
  
  22. // prints true 
    23. 
  
  
  
  23. console.log(instanceA === instanceB); 
    24.

在上面的代码中，我们通过调用 singleton.getInstance 方法来创建一个新实例。如果实例已经存在，则此方法仅返回该实例。如果该实例不存在，则通过调用该 init() 函数创建一个新实例。

五、工厂模式

工厂模式使用工厂方法创建对象而不需要指定具体的类或构造函数的模式。

工厂模式用于创建对象而不需要暴露实例化的逻辑。当我们需要根据特定条件生成不同的对象时，可以使用此模式。例如：

 
 
 
    
  
  
  
  1. class Car{ 
    2. 
  
  
  
  2.   constructor(options) { 
    3. 
  
  
  
  3.     this.doors = options.doors || 4; 
    4. 
  
  
  
  4.     this.state = options.state || 'brand new'; 
    5. 
  
  
  
  5.     this.color = options.color || 'white'; 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. class Truck { 
    9. 
  
  
  
  9.   constructor(options) { 
    10. 
  
  
  
  10.     this.doors = options.doors || 4; 
    11. 
  
  
  
  11.     this.state = options.state || 'used'; 
    12. 
  
  
  
  12.     this.color = options.color || 'black'; 
    13. 
  
  
  
  13.   } 
    14. 
  
  
  
  14. } 
    15. 
  
  
  
  15. class VehicleFactory { 
    16. 
  
  
  
  16.   createVehicle(options) { 
    17. 
  
  
  
  17.     if(options.vehicleType === 'car') { 
    18. 
  
  
  
  18.       return new Car(options); 
    19. 
  
  
  
  19.     } else if(options.vehicleType === 'truck') { 
    20. 
  
  
  
  20.       return new Truck(options); 
    21. 
  
  
  
  21.       } 
    22. 
  
  
  
  22.   } 
    23. 
  
  
  
  23. } 
    24.

这里，创建了一个 Car 和一个 Truck 类(具有一些默认值)，该类用于创建新的 car 和 truck对象。而且定义了一个VehicleFactory 类，用来根据 options 对象中的 vehicleType 属性来创建和返回新的对象。

 
 
 
    
  
  
  
  1. const factory = new VehicleFactory(); 
    2. 
  
  
  
  2. const car = factory.createVehicle({ 
    3. 
  
  
  
  3.   vehicleType: 'car', 
    4. 
  
  
  
  4.   doors: 4, 
    5. 
  
  
  
  5.   color: 'silver', 
    6. 
  
  
  
  6.   state: 'Brand New' 
    7. 
  
  
  
  7. }); 
    8. 
  
  
  
  8. const truck= factory.createVehicle({ 
    9. 
  
  
  
  9.   vehicleType: 'truck', 
    10. 
  
  
  
  10.   doors: 2, 
    11. 
  
  
  
  11.   color: 'white', 
    12. 
  
  
  
  12.   state: 'used' 
    13. 
  
  
  
  13. }); 
    14. 
  
  
  
  14. // Prints Car {doors: 4, state: "Brand New", color: "silver"} 
    15. 
  
  
  
  15. console.log(car); 
    16. 
  
  
  
  16. // Prints Truck {doors: 2, state: "used", color: "white"} 
    17. 
  
  
  
  17. console.log(truck); 
    18.

我为类 VehicleFactory 创建了一个新的 factory 对象。然后，我们通过调用 factory.createVehicle 方法并且传递 options 对象，其 vehicleType 属性可能为 car 或者 truck 来创建新 Car 或 Truck 对象。

六、装饰器模式

装饰器模式用于扩展对象的功能，而无需修改现有的类或构造函数。此模式可用于将特征添加到对象中，而无需修改底层的代码。

此模式的一个简单示例为：

 
 
 
    
  
  
  
  1. function Car(name) { 
    2. 
  
  
  
  2.   this.name = name; 
    3. 
  
  
  
  3.   // Default values 
    4. 
  
  
  
  4.   this.color = 'White'; 
    5. 
  
  
  
  5. } 
    6. 
  
  
  
  6. // Creating a new Object to decorate 
    7. 
  
  
  
  7. const tesla= new Car('Tesla Model 3'); 
    8. 
  
  
  
  8. // Decorating the object with new functionality 
    9. 
  
  
  
  9. tesla.setColor = function(color) { 
    10. 
  
  
  
  10.   this.color = color; 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12. tesla.setPrice = function(price) { 
    13. 
  
  
  
  13.   this.price = price; 
    14. 
  
  
  
  14. } 
    15. 
  
  
  
  15. tesla.setColor('black'); 
    16. 
  
  
  
  16. tesla.setPrice(49000); 
    17. 
  
  
  
  17. // prints black 
    18. 
  
  
  
  18. console.log(tesla.color); 
    19.

这种模式的一个更实际的例子是：

假设汽车的成本取决于其功能的数量。如果没有装饰器模式，我们将不得不为不同的功能组合创建不同的类，每个类都有一个 cost 方法来计算成本。例如：

 
 
 
    
  
  
  
  1. class Car() { 
    2. 
  
  
  
  2. } 
    3. 
  
  
  
  3.  
    4. 
  
  
  
  4. class CarWithAC() { 
    5. 
  
  
  
  5. } 
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. class CarWithAutoTransmission { 
    8. 
  
  
  
  8. } 
    9. 
  
  
  
  9.  
    10. 
  
  
  
  10. class CarWithPowerLocks { 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12.  
    13. 
  
  
  
  13. class CarWithACandPowerLocks { 
    14. 
  
  
  
  14. } 
    15.

但是，通过装饰器模式，我们可以创建一个基类 car 并且通过装饰器函数给不同的对象添加对应的成本逻辑。

 
 
 
    
  
  
  
  1. class Car { 
    2. 
  
  
  
  2.   constructor() { 
    3. 
  
  
  
  3.   // Default Cost 
    4. 
  
  
  
  4.   this.cost = function() { 
    5. 
  
  
  
  5.   return 20000; 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. } 
    9. 
  
  
  
  9. // Decorator function 
    10. 
  
  
  
  10. function carWithAC(car) { 
    11. 
  
  
  
  11.   car.hasAC = true; 
    12. 
  
  
  
  12.   const prevCost = car.cost(); 
    13. 
  
  
  
  13.   car.cost = function() { 
    14. 
  
  
  
  14.     return prevCost + 500; 
    15. 
  
  
  
  15.   } 
    16. 
  
  
  
  16. } 
    17. 
  
  
  
  17. // Decorator function 
    18. 
  
  
  
  18. function carWithAutoTransmission(car) { 
    19. 
  
  
  
  19.   car.hasAutoTransmission = true; 
    20. 
  
  
  
  20.    const prevCost = car.cost(); 
    21. 
  
  
  
  21.   car.cost = function() { 
    22. 
  
  
  
  22.     return prevCost + 2000; 
    23. 
  
  
  
  23.   } 
    24. 
  
  
  
  24. } 
    25. 
  
  
  
  25. // Decorator function 
    26. 
  
  
  
  26. function carWithPowerLocks(car) { 
    27. 
  
  
  
  27.   car.hasPowerLocks = true; 
    28. 
  
  
  
  28.   const prevCost = car.cost(); 
    29. 
  
  
  
  29.   car.cost = function() { 
    30. 
  
  
  
  30.     return prevCost + 500; 
    31. 
  
  
  
  31.   } 
    32. 
  
  
  
  32. } 
    33.

首先，我们创建了小轿车的基类 Car。然后针对要添加的特性创建了装饰器并且此装饰器以 Car 对象为参数。然后通过返回更新后的小汽车成本来覆盖对象的成本函数，且添加了一个用来标识某个特性是否已经被添加的属性。

要添加新的功能，我们只需要像下面一样就可以：

 
 
 
    
  
  
  
  1. const car = new Car(); 
    2. 
  
  
  
  2. console.log(car.cost()); 
    3. 
  
  
  
  3. carWithAC(car); 
    4. 
  
  
  
  4. carWithAutoTransmission(car); 
    5. 
  
  
  
  5. carWithPowerLocks(car); 
    6.

最后，我们可以像这样计算汽车的成本：

 
 
 
    
  
  
  
  1. // Calculating total cost of the car 
    2. 
  
  
  
  2. console.log(car.cost()); 
    3.

结论

我们已经了解了 JavaScript 中使用的各种设计模式，但是这里没有涉及到可以用 JavaScript 实现的设计模式。

尽管了解各种设计模式很重要，但不要过度使用它们也同样重要。在使用设计模式之前，你应该仔细考虑你的问题是否适合该设计模式。要知道某个模式是否适合你的问题，应该好好研究该设计模式以及它的应用。

当前文章：JavaScript的7种设计模式
转载来于：http://www.shufengxianlan.com/qtweb/news20/521870.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站设计公司知识

同城分类信息

注册域名　　 　重庆做网站　　 　重庆服务器托管　　 　成都西信服务器托管　　 　微信公众号二次开发　　 　格蓝特设备　　 　绵阳电信机房　　 　成都小程序开发公司　　 　胜锦安防科技　　 　成都广告制作　　 　成都搅拌罐车　　 　梓潼做网站　　 　东电技服　　 　温江服务器租用　　 　香港空间　　 　成都印刷厂　　 　重庆移动机房托管　　 　温江做网站　　 　眉山联通机房　　 　手机网站建设