设计模式分享-单例

最新推荐文章于 2024-09-30 16:40:56 发布

倒不了的dota

最新推荐文章于 2024-09-30 16:40:56 发布

阅读量948

点赞数 15

文章标签：设计模式前端单例模式开闭原则

本文链接：https://blog.csdn.net/yw6695767/article/details/142655878

版权

设计模式分类

创建型模式
- 工厂方法模式、抽象工厂模式、生成器模式、原型模式、单例模式
结构型模式
- 适配器模式、桥接模式、组合模式、装饰模式、外观模式、享元模式、代理模式
行为模式
- 责任链模式、命令模式、迭代器模式、中介者模式、观察者模式、访问者模式…

一、单例模式

单例模式：限制类实例化次数只能一次，一个类只有一个实例，并提供一个访问它的全局访问点。

概念：

单例模式，属于创建型模式的一种，是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。在这里插入图片描述

优点：

在内存中只有一个对象，减少了内存的开销。
为该实例提供一个全局访问节点，避免了对共享资源的多重访问。

缺点：

单例模式由于只有一个实例存在，可能会导致共享状态的问题，虽然在使用上十分方便，但同时也非常不安全，因为任何代码都有可能覆盖掉那些变量的内容，从而引发程序崩溃
对扩展不友好，不易于替换或修改单例类的实现，无法继承

二、不同语言实现方式

Java应用场景：

单例模式只允许创建一个对象，因此适用于需要控制对象数量的场景，如系统配置、日志记录、资源管理器等。
单例模式可以在系统启动时初始化对象，因此适用于需要在系统启动时进行初始化的场景，如读取配置文件、创建数据库连接等。
单例模式可以提供全局的访问点，因此适用于需要全局访问的对象，如线程池、缓存等。
Java代码示例

public class Singleton {  
    private static Singleton instance;  
    // 私有构造函数，防止外部直接创建对象  
    private Singleton() {  
    }  
    // 公共静态方法，获取单例实例  
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

单例的实现都包含以下两个相同的步骤：

将默认构造函数设为私有，防止其他对象使用单例类的 new 运算符。
新建一个公有静态构建方法作为构造函数。类的静态方法仍能调用构造函数来创建对象，并将其保存在一个静态成员变量中。此后所有对于该函数的调用都将返回这一缓存对象

JavaScript几种实现方式

使用对象字面量

let Singleton = {
  // 成员属性和方法
  property: 10,

  method: function() {
    return 'ethod';
  }
};

使用立即调用的函数表达式

let Singleton = (function() {
  let instance;

  function createInstance() {
    // 私有属性和方法
    let privateProperty = 'private';

    return {
      publicProperty: 10,

      publicMethod: function() {
        console.log(privateProperty);
        // 其他逻辑
      }
    };
  }

  return {
    getInstance: function() {
      if (!instance) {
        instance = createInstance();
      }
      return instance;
    }
  };
})();

let singleton = Singleton.getInstance();

使用 ES6 的类

class Singleton {
  constructor() {
    if (!Singleton.instance) {
      Singleton.instance = this;
    }
    return Singleton.instance;
  }

  // 成员方法
  method() {
    // 逻辑
  }
}

下面是一个简单的用NodeJS实现单例模式的例子：

class Singleton {
  constructor(data) {
    if (Singleton.instance) {
      return Singleton.instance;
    }
    Singleton.instance = this;
    this.data = data;
  }

  getData() {
    return this.data;
  }
}

// 创建第一个实例
const singleton = new Singleton("data1");
console.log(singleton.getData()); // 输出："data1"

// 尝试创建第二个实例
const singleton2 = new Singleton("data2");
console.log(singleton2.getData()); // 输出："data1"

// single 和 single2 实际上指向相同的实例
console.log(singleton === singleton2); // 输出：true

当你尝试创建 Singleton 的新实例时，如果已经存在一个实例 Singleton.instance，那么构造函数将返回这个已经存在的实例，而不是创建一个新的。因此，无论你创建多少次，都只会得到同一个实例

ES6中使用单例

在ES6中，可以使用export导出一个单例类的实例，然后在其他文件中使用import引入该实例。这种方式需要使用模块化开发方式，适用于大型应用程序。

class Singleton {
    constructor() {
        this.name = 'I am singleton';
    }
 
    method1() {
        // do something...
    }
}
 
const instance = new Singleton();
 
export default instance;

在另外一个文件中使用import引入该实例：

import singleton from './singleton';
 
console.log(singleton.name); // "I am singleton"

通用获取单例模式——高阶函数

如果我们需要一个通用的获取单例的方式，不用具体去实现某种单例。用高级函数可以很好地实现这一点

const getSingle = (fn) => {
  var result;
  return (...arg) => {
    return result ?? (result = fn(...arg));
  };
};

这段代码定义了一个高阶函数 getSingle，该函数接受一个函数 fn 作为参数，返回一个新的函数。新函数在其生命周期内只会执行一次 fn。
新函数在第一次被调用时会执行 fn 并将结果存储在 result 中，以后的调用会直接返回 result，并不会执行 fn。

这种模式也被称为“惰性计算”或“单例模式”。

以下是一个使用这个函数的简单示例：

const getSingleDate = getSingle(() => new Date());
console.log(getSingleDate()); // 输出第一次调用的日期和时间
console.log(getSingleDate()); // 输出和第一次调用相同的日期和时间，即使在后续的调用中时间已经变化

请注意，result 的值不是在 getSingle 函数执行时决定的，而是在新函数第一次被调用时决定的，这使得计算能够被推迟到真正需要结果的时候。
只有 result 为 null 或 undefined 时， result 才会被赋值为 fn(…arg) 的结果。如果 result 已经有了一个值，那么计算不会被执行。这是一个在 JavaScript 中实现惰性计算的常见模式。

综上：单例模式适合应用场景

如果程序中的某个类对于所有客户端只有一个可用的实例，可以使用单例模式
如果你需要更加严格地控制全局变量，可以使用单例模式

三、高阶函数和闭包

高阶函数的概念

高阶函数（Higher-order Function）是函数式编程中的一个重要概念。在 JavaScript 中，函数被视为一等公民，这意味着函数同样可以作为参数被传递，也可以作为返回值返回，这同时也是高阶函数存在的基础。

具体来说，高阶函数要满足以下两个条件之一：

接收一个或多个函数作为参数。
返回一个新的函数。

高阶函数主要关注的是函数的输入和输出，特别是这些输入和输出也可以是函数。一个高阶函数可以接收一个或多个函数作为参数，或者返回一个函数。
闭包是关于函数作用域和变量访问的。闭包发生在一个函数内部创建了另一个函数，并访问了外部函数的局部变量一种情景。

高阶函数应用

高阶函数在实际开发中非常实用，主要应用如下：

抽象通用的问题：高阶函数可以帮助我们从其他函数中抽离出通用的问题，比如 Array 的 map，filter，reduce 函数就是典型的高阶函数，他们将 “遍历数组” 这个通用问题抽离出来，让开发者可以将更多的精力放在如何处理数组元素上。

   let arr = [1, 2, 3, 4, 5];
   let newArr = arr.map(num => num * 2); // [2, 4, 6, 8, 10]

控制函数的执行时间：通过高阶函数，我们可以控制一个函数何时执行，比如上面提到的单例模式生成函数，又或者是 debounce 和 throttle 函数。

在使用高阶函数的过程中，有一个重要的概念要理解，那就是函数也是一种数据，我们可以将它作为参数传递给其他函数，也可以作为函数的返回值，这是 JavaScript 函数式编程的一个基本原则。理解这一原则，高阶函数就非常容易理解和应用了。
debounce 和 throttle 函数都是闭包的实际应用。它们都通过闭包来访问和控制从外部函数（也就是 debounce 和 throttle 函数本身）中引入的状态变量。

无论是 debounce 还是 throttle 函数，其主要目的都是控制传入的函数在一段时间内的执行次数。为了实现这个目的，它们内部都需要维护一些状态，比如最后一次调用的时间、当前是否正在等待执行等。

这些状态变量被外部函数（也就是 debounce 或 throttle）捕获，并在它们所返回的那个新的函数（经过 debounce 或 throttle 处理的那个函数）中持续使用。由于新的函数可以持续访问并修改这些状态变量，因而构成了一个闭包。

以 debounce 为例：

function debounce(func, delay) {
    let timer;
    return function(...args) {
        clearTimeout(timer);
        timer = setTimeout(() => {
          func.apply(this, args);
         }, delay);
    };
 }

在这里，timeout 就是一个由 debounce 函数捕获的状态变量，在返回的新函数中被持续使用，因此这就构成了一个闭包。

闭包就是在 JavaScript 中，内部函数访问其外部函数作用域中的变量或参数。在以上的 debounce 函数中，内部函数（setTimeout的回调函数）可以访问到外部函数（debounce和返回的新函数）的变量或参数（比如func，wait，timeout）。这也是典型的闭包。

闭包的概念

闭包是一个函数与其词法环境的结合。这个词法环境包含了闭包创建时它的上下文中所有的本地变量。简单来说，闭包就是一个函数嵌套在另一个函数内部，这个内部函数可以访问外部函数的变量。

在 JavaScript 中，当一个函数被声明时，会创建一个闭包，它包括该函数本身以及能访问的环境。由于 JavaScript 支持高阶函数，我们可以返回一个函数，这个返回的函数能够记住并访问其被声明时所在的作用域（也就是闭包）。

闭包的特点：

内部函数可以访问外部函数的变量，甚至是全局变量。
闭包可以记住并访问所在的外部函数的变量和参数（即使外部函数已经返回）。
通过闭包可以创建私有变量，防止全局环境被污染。

例如：

function outer() {
    var outerVar = 'I am from outer function';
    function inner() {
        console.log(outerVar); //访问外部函数的变量
    }
    return inner;
}
var innerFunc = outer();
innerFunc(); // "I am from outer function"

在上述例子中，outer函数返回inner函数，innerFunc得到的实际上是outer的内部函数inner。尽管outer函数已经返回，但inner函数仍然可以访问outer函数的变量outerVar，这就是典型的闭包。

四、项目代码实践（demo）

// 创建单例类
class EmitterSingleton {
  private static instance: EmitterSingleton;
  private emitter: Emitter<Events>;

  private constructor() {
    this.emitter = mitt<Events>();
  }

  public static getInstance(): EmitterSingleton {
    if (!EmitterSingleton.instance) {
      EmitterSingleton.instance = new EmitterSingleton();
    }
    return EmitterSingleton.instance;
  }
  ...
}

// 导出单例实例
const emitterInstance = EmitterSingleton.getInstance();
export default emitterInstance;

export class ComponentLib {
  ...
      static getInstance(blockPrefix: string): ComponentLib {
        // 检查是否存在实例，如果不存在则创建
        if (!ComponentLib._instance) {
          ComponentLib._instance = new ComponentLib(blockPrefix);
        }
        return ComponentLib._instance;
      }
  ...
  }
const componentLib = ComponentLib.getInstance('');
export default componentLib;

// 4. 创建实例并初始化
const $$sdk = new LynxSDK();

console.info('CHANNEL: ', CHANNEL);
$$sdk.init({
  app_id: APP_ID.cn[region],
  channel: CHANNEL || ('cn' as any),
  ...(CHANNEL === 'cn' ? { channel_domain: 'XXX' } : {}),
});
$$sdk.config({});

$$sdk.send();

export const sendTeaEvent = <TEventName extends EVENT_NAMES>(
  event: TEventName,
  params?: ParamsTypeDefine[TEventName],
) => {
  $$sdk.event(event, params);
};

  export default class ChatSDK {
  ...
  /**
   * 创建chatBot实例
   *1. 对于同一个 bot_id/preset_bot, 重复调用，sdk 只会创建一个实例
   *2. 多个 bot_id/presetBot，对应多个 sdk 实例，维护自己的events
   */
  static create(props: CreateProps) {
    const { unique_key } = ChatSDK.getUniqueKey(props);
    // 对于同一个 bot_id/preset_bot, 重复调用，create只会创建一个实例
    if (ChatSDK.instances.has(unique_key)) {
      console.error('重复创建实例');
      return ChatSDK.instances.get(unique_key);
    }

    const instance = new ChatSDK(props);
    ChatSDK.instances.set(unique_key, instance);
    return instance;
  }
  ...
}