Ventajas y desventajas del patrón Singleton en diseño de software

Clase 6 de 27 • Curso de Patrones de Diseño en JavaScript

Resumen

¿Cuáles son las ventajas del patrón Singleton?

El patrón Singleton es uno de los patrones de diseño más discutidos debido a su utilidad controvertida en el desarrollo de software. Ahora, ¿por qué podría considerarse ventajoso? Examinemos sus aspectos más destacados.

Certeza de una sola instancia: Al usar un Singleton, tenemos garantizado que solo existirá una instancia de la clase en cuestión. Esto se logra a través de un constructor privado y un método público para obtener la instancia, asegurándonos de que siempre se esté utilizando el mismo objeto.
Punto de acceso global: La clase Singleton ofrece un único punto de acceso global a esa instancia. Esto es beneficioso cuando necesitamos compartir datos o modificar los elementos internos del objeto de manera centralizada.
Inicialización diferida: La instancia del Singleton se crea solo cuando se solicita por primera vez. Aunque podemos llamar al método getInstance múltiples veces, la instancia solo se genera en la primera invocación, optimizando así los recursos.

¿Cuáles son los inconvenientes del patrón Singleton?

A pesar de sus ventajas, el patrón Singleton viene con unas cuantas desventajas que hacen cuestionar su uso en ciertas situaciones. Veamos algunas de las críticas principales:

Violación del principio de responsabilidad única: Un Singleton maneja tanto la creación de instancias como el acceso, lo que lleva a que la clase realice más de una función y se complique más de lo necesario, especialmente en grandes proyectos.
Complejidad en entornos multihilo: Implementar Singleton en sistemas multithread puede ser complicado, ya que debemos decidir qué hilo será responsable de crear y compartir la instancia de manera segura.
Dificultad en pruebas unitarias: Los Singletons complican la creación de pruebas unitarias, porque su instancia única hace difícil personalizar configuraciones o experimentar con diferentes parámetros, lo que puede requerir amplia y compleja configuración.

¿Cuándo deberías usar un Singleton?

A pesar de los inconvenientes mencionados, existen situaciones donde un Singleton puede ser aprovechado eficazmente. El truco está en saber cuándo y cómo utilizar este patrón en nuestros proyectos.

Usa un Singleton cuando:

Necesites un único punto de acceso a recursos compartidos que sean utilizados por varios componentes.
Implementes una característica que requiera compartición de estado o información entre partes de la aplicación.

Contexto errado: Un ejemplo comúnmente malinterpretado es el uso de Singleton para manejar conexiones a bases de datos. Sin embargo, esto puede llevar a problemas de memoria y rendimiento, ya que sería ineficaz procesar múltiples solicitudes (por ejemplo, 10,000) con una sola conexión. Para este tipo de problema, un pool de conexiones es una solución más adecuada.

Reto práctico: Implementar un Singleton

Para poner en práctica este conocimiento, te invito a construir tu propio Singleton. Diseña una clase Shopping Cart, exclusiva y única para cada usuario en una aplicación de comercio electrónico. Esta clase contendrá una lista de productos y métodos para añadir o eliminar productos por su ID. Asegúrate de incluir un método getInstance que siga el patrón Singleton.

Esta propuesta no solo te ayudará a comprender las ventajas y desventajas del patrón, sino que también fomentará análisis crítico sobre cuándo y cómo usarlo. Reflexionarás sobre si el Singleton es un aliado valioso o un detractor en tus proyectos.

¡Pon en práctica tus habilidades, y comparte tu solución y reflexiones sobre el uso de Singleton! Aporta a la discusión, y aprendamos juntos sobre su lugar en el diseño de software.

Francisco Rappazzini

student•

Les dejo mi codigo en TypeScript:

class Product {
  private id: number;
  private name: string;
  private cost: number;

  constructor(id: number, name: string, cost: number) {
    this.id = id;
    this.name = name;
    this.cost = cost;
  }

  getId() {
    return this.id;
  }

  getName() {
    return this.name;
  }

  getCost() {
    return this.cost;
  }
}

class ShoppingCart {
  private static instance: ShoppingCart;
  private cart: Product[] = [];

  private constructor() {}

  getCart() {
    return this.cart;
  }

  add(product: Product) {
    this.cart.push(product);
  }

  deleteById(id: number) {
    this.cart = this.cart.filter((prod) => prod.getId() !== id);
  }

  static getInstance() {
    if (!this.instance) this.instance = new ShoppingCart();
    return this.instance;
  }
}

(() => {
  const cart = ShoppingCart.getInstance();
  const cart2 = ShoppingCart.getInstance();
  const prod1 = new Product(1, "mate", 3000);
  const prod2 = new Product(2, "bombilla", 2900);
  const prod3 = new Product(3, "matera", 2400);

  // agregamos products al cart
  cart.add(prod1);
  cart.add(prod2);
  cart.add(prod3);

  console.log(cart.getCart());

  // borramos por id
  cart.deleteById(2);

  console.log(cart.getCart());

  // verificamos que ambos cart tienen la misma instancia, por tanto ambos tienen los mismos products
  console.log(cart === cart2);
  console.log(cart.getCart());
  console.log(cart2.getCart());
})();

Daniel Basulto

teacher•

Excelente Francisco, lo tienes!

Quedaron claros los conceptos detrás de la implementación de Singleton?

Royer Adrian Ojeda Carrion

student•

Super bien!!!!!

Eday Alix González Manjarrés

student•

Hasta este punto del curso, me hubiese gustado profundizar más en diferentes casos de uso que pudiese tener el Patrón Singleton en desarrollo de software, pues de esta manera es como se podría interiorizar el concepto de mejor forma.

Gracias.

Daniel Basulto

teacher•

Muchar gracias por el feedback Eday, tomando notas para los siguientes.

luis carlos rojano vergara

student•

Esta version implementa un carrito diferente para cada usuario, utilizando el patron singleton:

const PRODUCTS: Product[] = [
  { name: "apple", id: 1, cost: 2000 },
  { name: "banana", id: 2, cost: 500 },
  { name: "coconut", id: 3, cost: 3000 },
  { name: "meat", id: 4, cost: 20000 },
  { name: "pineapple", id: 5, cost: 1000 },
  { name: "coke", id: 6, cost: 1800 },
] as Product[];

interface Product {
  id: number;
  name: string;
  cost: number;
  getName(): string;
  getCost(): number;
  getId(): number;
}

interface cart {
  add(product: Product): void;
  deleteById(id: number): void;
  getInstance(client: string): ShoppingCart;
}

class ShoppingCart implements cart {
  private products: Product[] = [];
  private constructor() {}

  static usersCarts: Record<string, ShoppingCart> = {};

  static getInstance(client: string): ShoppingCart {
    return this.usersCarts[client]
      ? this.usersCarts[client]
      : new ShoppingCart();
  }

  add(product: Product): void {
    this.products.push(product);
  }

  deleteById(id: number): void {
    const productIndex = this.products.findIndex(
      (product) => product.id === id
    );
    if (productIndex !== -1) {
      this.products.splice(productIndex, 1);
    }
  }

  getTotal(): number {
    return this.products.reduce((total, product) => total + product.cost, 0);
  }
}

function clientApp() {
    const cartUser1 = ShoppingCart.getInstance("Client_1");
    const cartUser2 = ShoppingCart.getInstance("Client_2");
    const cartUser3 = ShoppingCart.getInstance("Client_3");
  
    cartUser1.add(PRODUCTS[0]);
    cartUser1.add(PRODUCTS[1]);
  
    cartUser2.add(PRODUCTS[2]);
    cartUser2.add(PRODUCTS[3]);
  
    cartUser3.add(PRODUCTS[4]);
    cartUser3.add(PRODUCTS[5]);
  
    // Display the cart contents and total cost for each user
    console.info("Cart Contents and Total Cost for Each User:");
  
    console.log("Client 1 Cart:");
    console.log("Cart Contents:", cartUser1);
    console.log("Total Cost:", cartUser1.getTotal());
  
    console.log("Client 2 Cart:");
    console.log("Cart Contents:", cartUser2);
    console.log("Total Cost:", cartUser2.getTotal());
  
    console.log("Client 3 Cart:");
    console.log("Cart Contents:", cartUser3);
    console.log("Total Cost:", cartUser3.getTotal());
  
    cartUser1.deleteById(PRODUCTS[0].id);
    cartUser2.deleteById(PRODUCTS[2].id);
    cartUser3.deleteById(PRODUCTS[4].id);
  
    // Display the updated cart contents and total cost for each user
    console.info("Cart Contents and Total Cost After Deletion for Each User:");
  
    console.log("Client 1 Cart:");
    console.log("Cart Contents:", cartUser1);
    console.log("Total Cost:", cartUser1.getTotal());
  
    console.log("Client 2 Cart:");
    console.log("Cart Contents:", cartUser2);
    console.log("Total Cost:", cartUser2.getTotal());
  
    console.log("Client 3 Cart:");
    console.log("Cart Contents:", cartUser3);
    console.log("Total Cost:", cartUser3.getTotal());
}

clientApp();

Daniel Basulto

teacher•

Supremo Luis!

Juan Esteban Mejia Ortiz

student•

Usen ChatGPT o Bard de google para solicitarle casos de uso reales, eso me ayudo a entender mejor.

Daniel Basulto

teacher•

Gran idea Juan, tomando nota para centrarnos en presentar mas casos de uso en los siguientes cursos.

Enrique Aguilera

student•

class Product {
    private id: number
    private name: string
    private cost: number

    public constructor(id: number, name: string, cost: number) {
        this.id = id
        this.name = name
        this.cost = cost
    }

    public getName(): string {
        return this.name
    }

    public getCost(): number {
        return this.cost
    }
    
    public getId(): number {
        return this.id
    }
}

class ShoppingCart {
    private static instance: undefined | ShoppingCart
    private products: Product[]
    
    private constructor() {
        this.products = []
    }

    public add(product: Product): void {
        this.products.push(product)
    }

    public deleteById(id: number): void {
        this.products = this.products.filter(product => product.getId() !== id)
    }

    public getProducts(): Product[] {
        return this.products
    }

    public static getInstance(): ShoppingCart {
        if(!ShoppingCart.instance) ShoppingCart.instance = new ShoppingCart()

        return ShoppingCart.instance
    }
}

function clientApp() {
    const silla = new Product(1, 'Silla de oficina', 10000)
    const mesa = new Product(2, 'Mesa para oficina', 20000)
    const lampara = new Product(3, 'Lampara de oficina', 5000)

    const shoppingCart = ShoppingCart.getInstance()

    // agregamos los productos al carrito
    shoppingCart.add(silla)
    shoppingCart.add(mesa)
    shoppingCart.add(lampara)

    console.log(shoppingCart.getProducts())

    // eliminamos un producto
    shoppingCart.deleteById(mesa.getId())

    console.log(shoppingCart.getProducts())
}

clientApp()

Daniel Basulto

teacher•

Buen trabajo Enrique!

Adrian Salvatori

student•

I think this should do it:

class ShoppingCart {
    static instance = undefined;

    constructor() {
        this.products = [];
    }

    getProducts = () => {
        return this.products;
    }

    addProduct = (product) => {
        return this.products.push(product);
    }

    deleteProductById = (id) => {
        return this.products = this.products.filter((product) => product.id !== id);
    }

    static getInstance = () => {
        if (!ShoppingCart.instance) ShoppingCart.instance = new ShoppingCart()
        return ShoppingCart.instance;
    }
}

class Product {
    constructor(id, name, cost) {
        this.id = id;
        this.name = name;
        this.cost = cost;
    }
    getID() {
        return this.id;
    }
    getName() {
        return this.name;
    }
    getCost() {
        return this.cost;
    }
}

const ClientApp = () => {
    const cart = ShoppingCart.getInstance();
    const vasos = new Product(1205, 'paquete de vasos', 12000);
    const zapatos = new Product(2166, 'zapatos - par', 57600)
    console.log(vasos.getName(), vasos.getCost(), vasos.getID());
    // Agregamos productos al carrito. 
    cart.addProduct(vasos);
    console.log('Agregamos vasos al cart', cart.getProducts());

    // confirmamos que el cart es el mismo, aún en otra instancia. 
    const cart2 = ShoppingCart.getInstance();
    cart2.addProduct(zapatos);
    console.log('Probamos que el nuevo cart también tiene productos', cart2.getProducts());

    // Borramos el producto y probamos en ambos carritos. 
    cart.deleteProductById(1205);
    console.log('Eliminamos vasos del cart', cart.getProducts(), cart2.getProducts());
}

ClientApp();

Daniel Basulto

teacher•

That's it Adrian!

A couple of questions:

The use of the static keyword was clear for you?
Why you choose arrow functions over normal functions in the shopping car implementation?

Adrian Salvatori

student•

Hey there, sorry, I wasn't around.

Yeah, I got the static keyword, It's pretty much a way of refferencing a property/method of the class itself, not of any instance or object created from this class. In this case, we're taking advantage of it to prevent the creation of multiple instances of the ShoppingCart class.
It was pretty much just a styling decision, as we're not actually having the "this binding" problem here.

Leandro Ayala

student•

Javascript no tiene hilos no? asi que son dos de tres?

Platzi

student•

Javascript no tiene hilos, por lo que el proceso de ejecución es sincrónico. Sin embargo, se puede simular la asincronía utilizando callbacks, promesas o async/await.

Edgar Alejandro España Amaya

student•

Apuntes:

Cosas cool

Certeza de que solo existirá una instancia de una clase.
Un solo punto de acceso global a dicha instancia.
La instancia es inicializada solo cuando se requiere la primera vez.

Cosas no tan cool

Vulnera el principio de responsabilidad única. El patrón resuelve dos problemas al mismo tiempo.
Complejidad incrementada en ambiente de múltiples hilos de ejecución ¿Cómo hacer que muchos hilos no creen un objeto singleton múltiples veces?
Complejidad a la hora de crear pruebas unitarias debido al uso de elementos estáticos

Kevin Ramirez

student•

Esta fue mi solucion para el reto, me costo pero lo logre comprender muy bien a la final

//Se crea la clase producto con sus atributos y métodos
class Product {
    constructor(id, name, cost) {
        this.id = id;
        this.name = name;
        this.cost = cost;
    }

    getId() {
        return this.id;
    }

    getName() {
        return this.name;
    }

    getCost() {
        return this.cost;
    }
}


//Se crea la clase carrito
class ShoppingCart {
    //Se crea su instancia que sea estatica
    static instance = undefined;

    constructor() {
        this.cart = [];
    }

    //Se crean sus diferentes metodos
    getCart() {
        return this.cart;
    }

    add(product) {
        this.cart.push(product);
    }

    deleteById(id) {
        this.cart = this.cart.filter((prod) => prod.getId() !== id);
    }

    //Se crea el metodo que llamara al constructor y retornara la instancia
    static getInstance() {
        if (!ShoppingCart.instance) ShoppingCart.instance = new ShoppingCart();
        return ShoppingCart.instance;
    }
}

function appSingleton() {
    const product1 = new Product(1, "Cafe", 3000)
    const product2 = new Product(2, "Atun", 5000)
    const product3 = new Product(3, "Gelatina", 1500)

    const cart1 = ShoppingCart.getInstance()
    const cart2 = ShoppingCart.getInstance()

    cart1.add(product1)
    cart1.add(product2)
    cart1.add(product3)

    cart1.deleteById(1)

    console.log(cart1.getCart());
    console.log(cart1 === cart2);
}

appSingleton()

Jorge Romero

student•

Mi solución

class ShoppingCar {
    
    static instance = {};

    constructor(cliente) {
        this.cliente = cliente;
        this.products = [];
    }

    static getInstance(cliente) {
        if(!ShoppingCar.instance[cliente]){
            ShoppingCar.instance[cliente] = new ShoppingCar(cliente);
        }

        return ShoppingCar.instance[cliente];
    }

    add(product) {
        this.products.push(product);
    }

    deleteById(id){
        const index = this.products.findIndex(product => product.id === id);
        if (index !== -1) {
            this.products.splice(index, 1);
        }
    }
}

class Product {
    
    constructor(id,name,cost){
        this.id = id;
        this.name = name;
        this.cost = cost;
    }

    getName() {
        return this.name;
    }

    getCost() {
        return this.cost;
    }

    getId() {
        return this.number;
    }
}

function clientApp() {
    const cliente1 = ShoppingCar.getInstance('cliente1');
    const cliente1copia = ShoppingCar.getInstance('cliente1');
    const cliente2 = ShoppingCar.getInstance('cliente2');

    cliente1.add(new Product(0,'Computadora',1200));
    cliente1.add(new Product(1,'Celular',850));
    cliente1.add(new Product(2,'Cubo Rubik',10));

    cliente1.deleteById(1);

    console.log(cliente1,cliente1copia);


    console.log(
        `cliente1 y cliente1copia son iguales? ${ cliente1 === cliente1copia ? 'yes' : 'no'}`
    );

    console.log(
        `cliente1 y cliente2 son iguales? ${ cliente1 === cliente2 ? 'yes' : 'no'}`
    );
}

clientApp();

Edwin Garcés Saucedo

student•

Les paso mi implementación de nuevo, porque el editor me falló.

Y el resultado:

Daniel Basulto

teacher•

Excelente Edwin, buena eleccion con la herramienta para compartir el codigo.

Miguel Ángel Garcia Beltran

student•

Hola, comparto mi solución, pense primero en usar .findIndex() y luego .splice() para el deleteById, aunque note en los comentarios que la mayoria usaron .filter():

class Product {
    private _id: number;
    private _name: string;
    private _cost: number;

    constructor(id: number, name: string, cost: number) {
        this._id = id;
        this._name = name;
        this._cost = cost;
    }

    get id() {
        return this._id;
    }
    get name() {
        return this._name;
    }
    get cost() {
        return this._cost;
    }
}

class ShoppingCar {
    private static instance: ShoppingCar;
    private _products: Array<Product>;

    private constructor() {
        this._products = [];
    }

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

    get products() {
        return this._products;
    }

    add(product: Product): void {
        this._products.push(product);
    }
    deleteById(id: number): void {
        const index = this._products.findIndex(product => product.id === id);
        if (index !== -1) this._products.splice(index, 1);
        else console.log("producto no encontrado");
    }
}

function clientApp() {
    const shoppingCar = ShoppingCar.getInstance();

    shoppingCar.add(new Product(1, "Collar Dorado", 200));
    shoppingCar.add(new Product(3, "Silla", 250));
    shoppingCar.add(new Product(2, "Vaso", 50));

    console.log(shoppingCar.products);

    shoppingCar.deleteById(1);
    shoppingCar.deleteById(1);

    console.log(shoppingCar.products);

    const shoppingCar2 = ShoppingCar.getInstance();
    console.log(shoppingCar === shoppingCar2);
}

clientApp();

Daniel Basulto

teacher•

A gusto del cliente Miguel, personalmente me gusta mas slice :)

Yohesky Pimentel

student•

Para hacer el eliminado puedes usar un filter por id, creo que queda mas sencillo

 this.products = this.products.filter((product) => product.id !== id);

Andres Eduardo Maneiro Antunez

student•

Les dejo como implemente el codigo del reto, espero sus feedback

Class Product

class Product {
    constructor(id, name, cost) {
        this._id = id;
        this._name = name;
        this._cost = cost;
    }
    getName() {
        return this._name;
    }
    getCost() {
        return this._cost;
        }
    getId() {
        return this._id;
    }
}

Class ShoppingCar

class ShoppingCar {
    static instance = undefined

    constructor() {
        this._products = []
    }

    static getInstance() {
        if(!ShoppingCar.instance) {
            ShoppingCar.instance = new ShoppingCar()
        }
        return ShoppingCar.instance
    }

    addProduct(product) {
        this._products.push(product)        
    }
    getProductById(id) {
        return this._products.find(product => product._id === id)
    }
    getProductByName(name) {
        return this._products.filter(product => product._name === name)
    }
    setProduct(newProductList) {
        this._products = newProductList
    }
    deleteProduct(id) {
        const deletedProduct = this.getProductById(id)
        const newProductList = this._products.filter(product => product._id !== id)
        this.setProduct(newProductList)
        return deletedProduct._name
    }
    getAllProduct() {
        return this._products
    }    
}

Cliente App para probar el funcionamiento del codigo

(function clienteApp() {
    const cart = ShoppingCar.getInstance();
    const vasos = new Product(1, "vasos plasticos" , 3)
    const zapatos = new Product(2, "gomas deportivas" , 30)
    const franela = new Product(3, "franela azul" , 25)
    const gorra = new Product(4, "gorra americana" , 10)
    const shorts = new Product(5, "shorts rojos" , 15)    

    cart.addProduct(vasos)
    cart.addProduct(zapatos)
    cart.addProduct(franela)
    cart.addProduct(gorra)
    /* Validamos que hay productos en el carrito */
    console.log(cart.getAllProduct);
    
    /* Instanciamos un segundo carrito y validamos que ya tiene productos*/
    const cart2 = ShoppingCar.getInstance();
    console.log(cart2.getAllProduct);
    /* Le agregamos un producto */
    cart2.addProduct(shorts);
    console.log(cart2.getAllProduct())
    /* Eliminamos un producto */
    console.log('Eliminamos exitosament el producto', cart.deleteProduct(2))

    /* Validamos que se elimino en ambos carritos */    
    console.log(cart.getAllProduct(),)
    console.log(cart2.getAllProduct())
})()

Fernando Quinteros Gutierrez

student•

class ShoppingCar { private static instance: ShoppingCar; public products: Product[] = []; private constructor() { } static getInstance(): ShoppingCar { if(!ShoppingCar.instance) { ShoppingCar.instance = new ShoppingCar(); } return ShoppingCar.instance; } public add(``product``: Product): void { this.products.push(``product``); } public deleteById(``id``: number): void { this.products = this.products.filter(``product`` => ``product``.getId() !== ``id``); }} class Product{ constructor(private ``id``: number, private ``name``: string, private ``cost``: number) { } public getId(): number { return this.id; } public getName(): string { return this.name; } public getCost(): number { return this.cost; }}

function app() { const shoppingCar = ShoppingCar.getInstance(); const product = new Product(1, 'TV', 1000); const product2 = new Product(2, 'PC', 2000); const product3 = new Product(3, 'Phone', 3000); shoppingCar.add(product); shoppingCar.add(product2); shoppingCar.add(product3); const shoppingCar2 = ShoppingCar.getInstance(); const product4 = new Product(4, 'video game', 4000); shoppingCar2.add(product4);

console.log(shoppingCar.products); shoppingCar.deleteById(2); console.log(shoppingCar.products); console.log(shoppingCar2.products);} app();

Fernando Quinteros Gutierrez

student•

```javascript

class ShoppingCar { private static instance: ShoppingCar; public products: Product[] = []; private constructor() { } static getInstance(): ShoppingCar { if(!ShoppingCar.instance) { ShoppingCar.instance = new ShoppingCar(); } return ShoppingCar.instance; } public add(product: Product): void { this.products.push(product); } public deleteById(id: number): void { this.products = this.products.filter(product => product.getId() !== id); }} class Product{ constructor(private id: number, private name: string, private cost: number) { } public getId(): number { return this.id; } public getName(): string { return this.name; } public getCost(): number { return this.cost; }}

function app() { const shoppingCar = ShoppingCar.getInstance(); const product = new Product(1, 'TV', 1000); const product2 = new Product(2, 'PC', 2000); const product3 = new Product(3, 'Phone', 3000); shoppingCar.add(product); shoppingCar.add(product2); shoppingCar.add(product3); const shoppingCar2 = ShoppingCar.getInstance(); const product4 = new Product(4, 'video game', 4000); shoppingCar2.add(product4);

console.log(shoppingCar.products); shoppingCar.deleteById(2); console.log(shoppingCar.products); console.log(shoppingCar2.products);} app();

```

Fernando Quinteros Gutierrez

student•

class ShoppingCar {
  private static instance: ShoppingCar;
  public products: Product[] = [];

  private constructor() { }

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

    return ShoppingCar.instance;
  }

  public add(product: Product): void {
    this.products.push(product);
  }

  public deleteById(id: number): void {
    this.products = this.products.filter(product => product.getId() !== id);
  }
}

class Product{
  constructor(private id: number, private name: string, private cost: number) { }

  public getId(): number {
    return this.id;
  }

  public getName(): string {
    return this.name;
  }

  public getCost(): number {
    return this.cost;
  }
}



function app() {
  const shoppingCar = ShoppingCar.getInstance();
  const product = new Product(1, 'TV', 1000);
  const product2 = new Product(2, 'PC', 2000);
  const product3 = new Product(3, 'Phone', 3000);
  shoppingCar.add(product);
  shoppingCar.add(product2);
  shoppingCar.add(product3);

  const shoppingCar2 = ShoppingCar.getInstance();
  const product4 = new Product(4, 'video game', 4000);
  shoppingCar2.add(product4);


  console.log(shoppingCar.products);

  shoppingCar.deleteById(2);

  console.log(shoppingCar.products);
  console.log(shoppingCar2.products);
}

app();
```class ShoppingCar {  private static instance: ShoppingCar;  public products: Product\[] = \[];
  private constructor() { }
  static getInstance(): ShoppingCar {    if(!ShoppingCar.instance) {      ShoppingCar.instance = new ShoppingCar();    }
    return ShoppingCar.instance;  }
  public add(*product*: Product): void {    this.products.push(*product*);  }
  public deleteById(*id*: number): void {    this.products = this.products.filter(*product* => *product*.getId() !== *id*);  }}
class Product{  constructor(private *id*: number, private *name*: string, private *cost*: number) { }
  public getId(): number {    return this.id;  }
  public getName(): string {    return this.name;  }
  public getCost(): number {    return this.cost;  }}


function app() {  const shoppingCar = ShoppingCar.getInstance();  const product = new Product(1, 'TV', 1000);  const product2 = new Product(2, 'PC', 2000);  const product3 = new Product(3, 'Phone', 3000);  shoppingCar.add(product);  shoppingCar.add(product2);  shoppingCar.add(product3);
  const shoppingCar2 = ShoppingCar.getInstance();  const product4 = new Product(4, 'video game', 4000);  shoppingCar2.add(product4);

  console.log(shoppingCar.products);
  shoppingCar.deleteById(2);
  console.log(shoppingCar.products);  console.log(shoppingCar2.products);}
app();

Daniel Basulto

teacher•

Ya lo tienes Fer!

Fermin Paez

student•

Buenas! Dejo mi implementación en Python

class Product:

    def __init__(self, id, name, cost):
        self._id = id
        self._name = name
        self._cost = cost

    def get_name(self):
        return self._name

    def get_cost(self):
        return self._cost
    
    def get_id(self):
        return self._id

class ShoppingCar:

    _instance = None
    _products = []

    def __new__(cls):
        if not cls._instance:
            cls._instance = super().__new__(cls)
        return cls._instance
    
    def add_product(self, product):
        self._products.append(product)

    def delete_by_id(self,id):
        for elemento in self._products:
            if elemento['id'] == id:
                self._products.remove(elemento)
    def show_products(self):
        return self._products

    @staticmethod
    def get_instance():
        return ShoppingCar()

class ClientApp:
    def __init__(self, id):
        self.id = id
        self.shopping_car = ShoppingCar.get_instance()

client = ClientApp(1)
client_2 = ClientApp(2)
print(client.shopping_car , client_2.shopping_car, client.shopping_car == client_2.shopping_car) # True
client.shopping_car.add_product(Product(1,'chocolate',22))

print(client.shopping_car == client_2.shopping_car, '#######')

Daniel Basulto

teacher•

Buenisimo Fermin!! DIria que tienes la idea muy clara, seguramente seras capaz de implementarlo en cualquier lenguaje.

Kevin Cantú Gómez

student•

Haciendo privada las propiedades de Product, es la forma en la que se me ocurrió después acceder a ellas mediante ShoppingCar.

class ShoppingCar{
    static #instanceSC = undefined;
    #products = [];
    
    addProduct(product){
        this.#products.push(product);
    }
    getProducts(){
        return this.#products;
    }

    deleteById(id){
        for (let n = 0; n < this.#products.length; n++) {
            if (this.#products[n].id === id) {
                this.#products.splice(n, 1);
                break; // Si los IDs son únicos, puedes salir del bucle una vez encontrado
            }
        }
        return this.#products;
    }
    static getInstance(){
        if(!ShoppingCar.#instanceSC){
            ShoppingCar.#instanceSC = new ShoppingCar();
        }
        return ShoppingCar.#instanceSC;
    }
}

class Product{
    #id;
    #name;
    #cost;

    constructor(id, name, cost) {
        this.#id = id;
        this.#name = name;
        this.#cost = cost;
    }

    getName() {
        return this.#name;
    }

    getCost() {
        return this.#cost;
    }

    getId() {
        return this.#id;
    }
}

const myShoppingCart = ShoppingCar.getInstance();
const myProduct = new Product(1, 'kevin', 100000);

myShoppingCart.addProduct(myProduct);

const products = myShoppingCart.getProducts();
products.forEach(product => {
    console.log(`ID: ${product.getId()}, Name: ${product.getName()}, Cost: ${product.getCost()}`);
});

Daniel Basulto

teacher•

Bien Kevin!

Eduardo Oswaldo Luna Silva

student•

I just want to share my solution in TS:

class ShoppingCart {
  private static instance: ShoppingCart;
  private cart: Product[] = [];

  private constructor() {}

  static getInstance(): ShoppingCart {
    if (!ShoppingCart.instance) {
      ShoppingCart.instance = new ShoppingCart();
    }
    return ShoppingCart.instance;
  }
  public getCart(): Product[] {
    return this.cart;
  }
  public addProduct(product: Product): void {
    this.cart.push(product);
  }
  public deleteById(id: number): void {
    let indexProduct = this.cart.findIndex((item) => item.getId() == id);
    this.cart.splice(indexProduct, 1);
  }
}

class Product {
  private id: number;
  private name: string;
  private cost: number;

  public constructor(id: number, name: string, cost: number) {
    this.id = id;
    this.name = name;
    this.cost = cost;
  }
  public getId(): number {
    return this.id;
  }
  public getName(): string {
    return this.name;
  }
  public getCost(): number {
    return this.cost;
  }
}

(() => {
  const cart = ShoppingCart.getInstance();
  const cart2 = ShoppingCart.getInstance();
  const p1 = new Product(1, "camara", 500);
  const p2 = new Product(2, "cama", 1500);
  const p3 = new Product(3, "cojin", 20);

  cart.addProduct(p1);
  cart.addProduct(p2);
  cart.addProduct(p3);

  console.log(cart.getCart());

  cart.deleteById(2);

  console.log(cart.getCart());
  // Verify the instance is the same in both carts
  console.log(cart === cart2);
  console.log(cart.getCart());
  console.log(cart2.getCart());
})();

```class ShoppingCart {  private static instance: ShoppingCart;  private cart: Product\[] = \[];
  private constructor() {}
  static getInstance(): ShoppingCart {    if (!ShoppingCart.instance) {      ShoppingCart.instance = new ShoppingCart();    }    return ShoppingCart.instance;  }  public getCart(): Product\[] {    return this.cart;  }  public addProduct(product: Product): void {    this.cart.push(product);  }  public deleteById(id: number): void {    let indexProduct = this.cart.findIndex((item) => item.getId() == id);    this.cart.splice(indexProduct, 1);  }}
class Product {  private id: number;  private name: string;  private cost: number;
  public constructor(id: number, name: string, cost: number) {    this.id = id;    this.name = name;    this.cost = cost;  }  public getId(): number {    return this.id;  }  public getName(): string {    return this.name;  }  public getCost(): number {    return this.cost;  }}
(() => {  const cart = ShoppingCart.getInstance();  const cart2 = ShoppingCart.getInstance();  const p1 = new Product(1, "camara", 500);  const p2 = new Product(2, "cama", 1500);  const p3 = new Product(3, "cojin", 20);
  cart.addProduct(p1);  cart.addProduct(p2);  cart.addProduct(p3);
  console.log(cart.getCart());
  cart.deleteById(2);
  console.log(cart.getCart());  // Verify the instance is the same in both carts  console.log(cart === cart2);  console.log(cart.getCart());  console.log(cart2.getCart());})();

Daniel Basulto

teacher•

Looks sweet Eduardo, good idea using IIF to run it.

Daniel Pacheco

student•

Mi sulocion Ts

class Product {
    private id: number;
    private name: string;
    private cost: number;

    constructor(id: number, name: string, cost: number) {
        this.id = id;
        this.name = name;
        this.cost = cost;
    }

    getid(): number {
        return this.id;
    };

    getName(): string {
        return this.name;
    };

    getCost(): number {
        return this.cost;
    };
};

class ShoppingCar {
    private static instance: ShoppingCar;
    private products: Product[];

    private constructor() {
        this.products = [];
    }

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

    addProduct(...product: Product[]) {
        this.products.push(...product)
    }

    getProducts(): Product[] {
        return this.products;
    }

    deleteById(id: number) {
        return this.products = this.products.filter(elem => elem.getid() !== id);
    }

}

// implementacion 
// crear una unica instancia de shopping car
const car = ShoppingCar.getInstance();
const car2 = ShoppingCar.getInstance();

// crear 2 products para poblar
let product1 = new Product(1, 'amp', 1500);
let product2 = new Product(2, 'guitar', 1700);

car.addProduct(product1, product2)

// comprobaciones en consola
console.log(`shold be true, ${car === car2}`);
console.log(car.getProducts());

Daniel Basulto

teacher•

Excelente Daniel.

Ventajas y desventajas del patrón Singleton en diseño de software

Introduccion

Patrones de Diseño Creacionales en Software

Patrones Creacionales: Singleton, Factory, Abstract Factory, Builder, Prototype

Singleton

Patrón Singleton: Implementación y Uso en Programación Orientada a Objetos

Diagrama de Clases del Patrón Singleton en JavaScript

Diferencias entre JavaScript y TypeScript en patrones de diseño