Singleton: constructor privado

Curso de TypeScript: Programación Orientada a Objetos y Asincronismo

Contenido del curso

Introducción

1
¿Ya tomaste el Curso de TypeScript: Tipos Avanzados y Funciones?
05:16 min

Fundamentos de POO

POO Avanzada

Asincronismo y consumo de APIs

Genéricos

Próximos pasos

25
¿Quieres más cursos de TypeScript?
01:20 min

Tomar examen

Singleton: constructor privado

Comentarios29

Carlos Andrés Jaramillo Villa

Estudiante

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

Bryan David Castañeda Aranzales

Estudiante

Tranquilo jajaja no eres el unico compa, he visto varios patrones de diseño y tampoco les encuentro una utilidad pero por algo las empresas lo deben de pedir, yo digo que es para casos muy especificos o para argumentar la solucion efectiva de un problema.

David Guevara

Estudiante

Hola, por ejemplo para una Clase maneja la conexión a una base de datos. Imagina que quieres tener solo 100 conexiones disponibles y estas se crean cuando se crean la instancia de la clase la primera vez. _ Podría pasar que si creas una nueva instancia de la clase se crean 100 conexiones mas ( buscar productos 100 + editar producto 100 …) hasta que la base de datos deje de responder. _ Otra cosa interesante es que los objetos ocupan memoria ram y podrías estar creando objetos muy grandes muchas veces innecesariamente y quedarte si memoria ram y que la app muera.

Miguel Angel Reyes Moreno

Estudiante

¡Qué interesante! :o

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

Gerardo Miranda

Estudiante

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

José Eras

Estudiante

Sí, debería.

mars Dev

Estudiante

Es lo mismo que me estaba preguntando jaja

Alex Maldonado

Estudiante

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

Luis Hernando Sendoya Serrato

Estudiante

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

Paola Alapizco

Estudiante

:computer: 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. . :movie_camera: Acá una lista de reproducción con más patrones de diseño . Espero este aporte les sea de ayuda :D

Gustavo Medina Limon

Estudiante

Buen aporte compañera, gracias!

Eduardo Robles

Estudiante

no es posible hacer este patron sin typescript?

Eder Ramirez

Estudiante

si se puede, de hecho es un patron que se puede implementar en cualquier lenguaje. Yo lo he implementado en Java programando para android

Jorge Aguilar

Estudiante

Se puede en TODOS los lenguajes de programación con el que estés trabajando el POO!!. Es un patrón de diseño!. no una característica del lenguaje.

Luis Lazcano

Estudiante

Además de crear un Singleton esto también hace que la Clase sea final. Una palabra reservada en lenguajes como Java que no permite la herencia. ¿Por que necesitarías eso? Uno de los principios de diseño es Composición sobre Herencia!

Jesus Daniel Castro Flores

Estudiante

por qué se menciona que es un antipatron en este hilo de StackOverflow?

Brahyan Antonio Martinez Madera

Estudiante

No es facil de plasmar pero son varias consideraciones :

No es necesario (No literalmente XD): En JavaScript, es fácil crear una variable global y acceder a ella desde cualquier lugar del código, por lo que no es necesario utilizar el patrón Singleton para proporcionar un acceso global a una instancia de una clase.
Dificulta la prueba: Si una clase es un Singleton, es difícil probarla de manera aislada, ya que siempre está vinculada a su única instancia. Esto puede hacer que sea más difícil escribir pruebas unitarias para la clase y puede dificultar la depuración de problemas.
Dificulta la escalabilidad: Si una clase es un Singleton, es difícil escribir código que dependa de ella de manera fácilmente reutilizable, ya que siempre está vinculada a su única instancia. Esto puede dificultar la escalabilidad del código a medida que se agreguen más funcionalidades.
Puede ser confuso: El patrón Singleton puede ser confuso para los desarrolladores que no están familiarizados con él, ya que puede no ser evidente que una clase es un Singleton y cómo se puede acceder a su única instancia.

En resumen, el patrón Singleton puede ser útil en algunos casos, pero en general es considerado un antipatrón en JavaScript y TypeScript debido a que puede dificultar la prueba, la escalabilidad y la legibilidad del código. Es mejor evitar su uso a menos que sea absolutamente necesario aunque la verdad es mejor saber que no saber XD, si llegaste hasta aca, gracias por leer todo GG 💙

Juan Castro

Profesor

Creo que esta clase te puede interesar: https://platzi.com/clases/6933-patrones-diseno-creacionales/60865-singleton-pros-y-contras/

María Carolina Guerra Gil

Estudiante

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

Alejandro Sebastian Dubon Estrada

Estudiante

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.

Álvaro Gabriel Soria Guzmán

Estudiante

¿Por qué se debe crear una sola instancia de una clase? tenía entendido que una clase es como un sello con el que se puede crear varios (estampas) objetos de dicha clase

David Rangel

Estudiante

•

Pues mira, un Singleton solía ser una forma de compartir datos o información entre componentes.

Por ejemplo, para una tienda en línea un Singleton servía para que al darle click a un producto, este le comunicara al carrito de compras y a la pasarela de pagos que seleccionaste "x" cantidad de "x" producto y que esta información persistiera aunque te cambiarias de sección, de página, etc, y todos te dirían que seleccionaste exactamente 3 productos de exactamente el "producto x".

Sin el Singleton no podrías comunicar esto o, si el singleton no fuera de una sola instancia, la página podría decir (con números inventados) que tienes 3 productos seleccionados de "producto y", el carrito podría decir que tienes 7 del "producto n" y la pasarela de pagos podría decir que tienes 1 del "producto y", porque no habría una fuente de verdad y podría cambiar la data por un cálculo, función intermedia, etc.

En React, el Singleton fue sustituido por el useState y los Context (Consumer y Provider), pues los Singletons aún con lo buenos que son pueden fallar.

En un proyecto real, un proveedor de por ejemplo servicios de autenticación, te podría decir que para usar su software tienes que conectarte a su api con ciertas keys y para poder usar su tecnología en tu software podrías usar instancias de las clases que proveen en su documentación, y estas clases pueden ser Singletons para tener consistencia en los datos.

Dario Mendoza

Estudiante

El patrón Singleton es un patrón de diseño que restringe la instanciación de una clase a un solo objeto. Esto es útil cuando se necesita exactamente un objeto para coordinar acciones a través del sistema. En programación orientada a objetos, este patrón asegura que una clase tenga una única instancia y proporciona un punto de acceso global a ella. En TypeScript, puedes implementar este patrón utilizando una propiedad estática que contenga la instancia y un constructor privado para evitar instancias externas.

Álvaro Gabriel Soria Guzmán

Estudiante

¡Gracias, que útil aclaración!

Diego Raciel Ortega Hernandez

Estudiante

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

Ronaldo Delgado

Estudiante

Me gustaría ver un ejemplo mas practico de este tema

Julian David Vidal González

Estudiante

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.

Andre Huaman Yovera

Estudiante

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.

Rafael Rodríguez Flores

Estudiante

Realmente en un patrón de TypeScript y de muchos ostros lenguajes, es un patrón, una plantilla, una forma de crear código habitual con un fin. Aquí se ve cómo se hace con TS pero se usa en más leguanjes con implementación similar ;)

brandon james grimaldo moscote

Estudiante

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

Carlos Alberto De Avila Suro

Estudiante

Los constructores privados no se suelen usar mucho, sin embargo hay un patrón que podemos aplicar haciendo uso de los constructores privados, ese patrón es Singleton, uno de los principios de la arquitectura Solid pero ¿De qué trata Singleton? Singleton garantiza que solo creemos una instancia de un objeto previniendo bloqueos de memoria y creación de muchas instancias de un solo objeto y además garantizando que solo tenemos un punto de acceso para esa instancia.

Cuando creamos una clase, normalmente la dotamos de un constructor de la siguiente manera

export class MyService {

constructor(private name:string){}

getName(){

return this.name

}

Si crearamos dos objetos a partir de esta misma clase

const myService1 = new MyService("entregaExpress")

console.log(myService1.getName())

const myService2 = new MyService("entrega pluss")

console.log(myService2.getName())

Obtendremos el siguiente resultado

entregaExpress

entrega plus

Si compararamos ambos objetos

console.log(myService1 === myService2)

El resultado sería

false

Lo cual significa que hemos creado dos objetos distintos

El propósito de Singleton es que cada vez que creemos un objeto a partir de una clase no se duplique sino que se use la instancia que previamente fué creada si es que lo fué y si no, se cree en ese momento, para ello usamos los constructores privados lo ilustramos modificando el ejemplo anterior.

Nuestro constructor quedaria de la siguiente manera private constructor(private name:string){}

De esta manera se restringe el constructor para que solo pueda ser usado dentro de la clase sometiendolo así a un control más riguroso

necesitaremos también una propiedad o variable estática con un valor inicial de null dentro de la clase la cual usaremos como bandera

static isService:MyService | null = null

Necesitaremos también un método estático que evalue el valor de la variable estatica (En nuestro caso isService) Si es nula se invoca el constructor para crear el objeto y asignarlo a la variable estatica misma que será devuelta con el nuevo objeto, si no fuera nula significa que ya se creo el objeto previamente y entonces solo la regresa con el objeto que previamente se le asignó

static creaServicio(name:string){

if(MyService.isService===null){

console.log("Esto solo se debe ejecutar una vez")

MyService.isService = new MyService(name)

}

return MyService.isService

}

El codigo completo de nuestra nueva clase quedaría así:

export class MyService {

static isService:MyService | null = null

private constructor(private name:string){}

static creaServicio(name:string){

if(MyService.isService===null){

console.log("Esto solo se debe ejecutar una vez")

MyService.isService = new MyService(name)

}

return MyService.isService

}

getName(){

return this.name

}

Entonces instanciamos el objeto a partir de nuestra clase

const myService1 = MyService.creaServicio("entregaExpress")

Al ejecutarlo por primera vez se crea el objeto y lo asigna a la variable myService1 si visualizamos su valor

console.log(myService1.getName())

obtendremos el nombre asignado

entregaExpress

Si repetimos el proceso como si fueramos a crear otro objeto de esta clase como el ejemplo de abajo

const myService2 = MyService.creaServicio("entrega pluss")

Nos percataremos de que como el objeto ya esta creado, no se vuelve a crear sino que ambas variables (myService1 y myService2 ) reciben el mismísimo objeto y lo podemos comprobar comparando ambas variables de la siguiente manera

console.log(myService1 === myService2)

Obtendremos true y ademas ya no se imprimira la siguiente linea

console.log("Esto solo se debe ejecutar una vez")

Con lo cual comprobamos que mediante este Singleton se pueden restringir las instancias de la clase.

Alvaro Andrade

Estudiante

Por que en la función create se utiliza MyService en lugar de this ?

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

this no es la referencia a la clase ?

Adriana Paredes Salinas

Estudiante

En la función create de la clase MyService, se utiliza MyService en lugar de this porque create es un método estático. Los métodos estáticos pertenecen a la clase en sí y no a instancias individuales de la clase. Por lo tanto, dentro de un método estático, no se puede hacer referencia a las propiedades o métodos de una instancia particular usando this.

En lugar de acceder a una instancia específica de la clase, los métodos estáticos generalmente se utilizan para realizar operaciones que son comunes a toda la clase o para crear instancias de la misma.

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

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"

Singleton: constructor privado

Introducción

¿Ya tomaste el Curso de TypeScript: Tipos Avanzados y Funciones?

Fundamentos de POO

Class

Métodos

Acceso público

Acceso privado

Constructor

Getters

Setters

POO Avanzada

Herencia

Acceso protegido

Static

Interfaces

Clases abstractas