Singleton: constructor privado

se me hace extranio entender en que forma sera util (se nota que falta mucha experiecia).
pero se ve interesante!.

¡Qué interesante! 😮

Singleton: constructor privado

Singleton nos previene crear múltiples instancias de una clase.

Esto es muy usado en Arquitectura de Software, pues nos ayuda a ahorrar uso de memoria.

export class MyService {
  static instance: MyService | null = null;

  private constructor(
    private name: string
  ) {}

  get Name() {
    return this.name;
  }

  static create(name: string) {
    if (MyService.instance === null) {
      console.log('Creating new instance');
      MyService.instance = new MyService(name);
    }
    return MyService.instance;
  }
}

const myService1 = MyService.create('MyService1');
console.log(myService1.Name)

const myService2 = MyService.create('MyService2');
console.log(myService2.Name)

const myService3 = MyService.create('MyService3');
console.log(myService3.Name)

console.log(myService1 === myService2); //* true
console.log(myService1 === myService3); //* true

la propiedad instace no debería se private para que no se pueda acceder a ella directamente desde fuera?

Aquí un archivo interesante para aprender sobre este patrón de diseño

💻 Para aquellos que quieran ir un poco más allá y entender mejor que es, como funciona, porque usar o no usar este patron de diseño, les dejo este enlace a un video de BettaTech donde lo explica a mayor detalle.
.
🎥 Acá una lista de reproducción con más patrones de diseño
.
Espero este aporte les sea de ayuda 😄

no es posible hacer este patron sin typescript?

Propósito

Singleton es un patrón de diseño creacional que nos permite asegurarnos de que una clase tenga una única instancia, a la vez que proporciona un punto de acceso global a dicha instancia.

https://refactoring.guru/es/design-patterns/singleton

Si quieres aprender un poco más sobre patrones de diseño te dejo este recurso que me pareció genial:

https://refactoring.guru/es/design-patterns

Esta clase estuvo muy buena, el patrón singleton nos sirve para crear una única instancia de algún objeto en específico… por ejemplo podemos gestionar conexiones a bases de datos.

Ya veo por que la gente dice que los patrones de diseño diferencian a un junior de un senior

Veo la utilidad cuando se trabaja con bases de datos, por ejem tienes varios modulos (archivos .ts) en los que necesitas interactuar con una base de datos, si te conectas a la misma base de datos desde cada modulo, va a haber un delay y puede producir bugs, con singleton, si te contectas a la base de datos una vez, siempre vas a usar la misma conexión no importa si llamas la funcion “connect” mas de una vez en diferentes modulos.

En TypeScript, el patrón Singleton se utiliza para asegurarse de que solo exista una instancia de una clase en todo el programa. Esto es útil cuando necesitas tener acceso a un objeto único desde múltiples partes del código.
.
Aquí tienes un ejemplo de cómo implementar un Singleton en TypeScript con un constructor privado:

class Singleton {
  private static instance: Singleton;  // La instancia única de la clase

  private constructor() {
    // El constructor privado evita la creación de instancias directamente
  }

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

    return Singleton.instance;
  }

  public showMessage(): void {
    console.log("Soy una instancia de Singleton");
  }
}

// Uso del Singleton
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2);  // true, ambas variables apuntan a la misma instancia

instance1.showMessage();  // "Soy una instancia de Singleton"
instance2.showMessage();  // "Soy una instancia de Singleton"

En este ejemplo, la clase Singleton tiene un constructor privado, lo que significa que no se puede crear una instancia directamente usando new Singleton(). En cambio, debemos utilizar el método estático getInstance() para obtener la instancia existente o crear una nueva si aún no existe.
.
Cuando llamamos a getInstance(), verificamos si la instancia ya existe. Si no existe, creamos una nueva instancia y la asignamos a la propiedad estática instance. Luego, devolvemos la instancia existente o recién creada.
.
Al utilizar el Singleton, podemos crear múltiples referencias a través de getInstance(), pero todas apuntarán a la misma instancia. Por eso, al comparar instance1 y instance2, obtenemos true. Además, ambas instancias pueden llamar al método showMessage() y mostrarán el mismo mensaje en la consola.
.
Espero que este ejemplo te haya ayudado a entender cómo se implementa un Singleton en TypeScript con un constructor privado. Si tienes alguna otra pregunta, no dudes en hacerla.

Esto es super útil, muy circunstancial pero super útil.

Casos de uso para Singleton:

• Acceso a recursos compartidos: Cuando hay recursos compartidos, como bases de datos, archivos de registro o conexiones de red, se puede utilizar el patrón Singleton para garantizar que solo exista una instancia de la clase que maneja esos recursos. Esto evita conflictos de acceso y garantiza que todos los componentes del sistema interactúen con la misma instancia.
• Configuración global: Si se necesita una configuración global accesible desde diferentes partes del sistema, el patrón Singleton puede utilizarse para mantener y acceder a esa configuración de manera centralizada. Por ejemplo, una clase Singleton de configuración podría almacenar valores como el idioma, la apariencia o las preferencias del usuario.
• Registro centralizado: En algunos casos, puede ser útil tener un registro centralizado de objetos o servicios disponibles en el sistema. El patrón Singleton puede utilizarse para implementar este registro y proporcionar acceso a los objetos registrados desde cualquier parte del sistema. Por ejemplo, un registro de servicios puede almacenar instancias únicas de clases que proporcionan funcionalidades específicas y permitir que otros componentes del sistema las utilicen mediante una interfaz común.

Sabia que los patrones de diseño eran muy importantes ya que definen la mejor forma de crear instancias y optimizar código limpio. Aunque principalmente por mi inexperiencia usando programación orientada a objetos soy incapaz de darle un uso por ahora. Pero se que en algún punto lo ocupare.