Qué aprendiste con patrones creacionales

Cursos Empresas Blog Live Conf Precios

Contenido del curso

Introduccion

Singleton

Factory

Abstract Factory

Builder

Prototype

Conclusiones

27
Qué aprendiste con patrones creacionales
Viendo ahora

Tomar examen

Qué aprendiste con patrones creacionales

Resumen

Cerrar el módulo de patrones creacionales marca un salto enorme en tu camino como developer: pasaste de aplicar herramientas de programación orientada a objetos sin contexto, a reconocer cuándo y por qué usarlas dentro de un diseño de software sólido. Si estás aprendiendo diseño de software con patrones, este es el momento de consolidar lo aprendido y prepararte para los siguientes bloques.

¿Qué aprendiste con los patrones creacionales?

Los patrones creacionales te dieron una caja de herramientas para resolver un problema muy concreto: cómo instanciar objetos de forma flexible, controlada y mantenible.

En el recorrido contrastaste varios conceptos de programación orientada a objetos que muchas veces se usan de forma mecánica:

Interfaces y cuándo conviene depender de abstracciones.
Herencia y sus límites cuando el diseño crece.
Métodos abstractos para forzar contratos en clases hijas.
Métodos estáticos y su relación con la creación de instancias.
Relaciones entre clases y por qué algunas decisiones escalan mejor que otras.

¿Qué son los patrones creacionales? Son soluciones reutilizables enfocadas en cómo se crean los objetos de un sistema, separando la lógica de instanciación del resto del código para ganar flexibilidad y mantenibilidad.

La diferencia entre un developer promedio y uno excelente no está en conocer la herramienta, sino en saber cuándo usarla. Esa es la idea que te llevas.

¿Qué sigue después de los patrones creacionales?

Dentro de la serie de diseño de software todavía quedan dos grandes categorías por explorar, y cada una resuelve problemas distintos al de la creación de objetos.

Patrones estructurales: cómo se componen y relacionan las clases y objetos entre sí.
Patrones de comportamiento: cómo se comunican y reparten responsabilidades los objetos.

¿Cuáles son las tres categorías de patrones de diseño? Creacionales, estructurales y de comportamiento. Los creacionales se enfocan en la instanciación, los estructurales en la composición y los de comportamiento en la interacción entre objetos.

La recomendación es clara: no pares de aprender. Cada patrón nuevo es una herramienta más en tu caja, y la suma es lo que termina marcando la diferencia en proyectos reales.

¿Cómo aprovechar al máximo lo aprendido en este curso?

Antes de cerrar, hay tres acciones que vale la pena ejecutar mientras el contenido está fresco.

Presenta el examen del curso para validar lo que entendiste de cada patrón.
Comparte tus soluciones a los retos de cada patrón creacional con la comunidad.
Deja tu feedback y califica el curso con cinco estrellas indicando qué mejorarías, si te gustaría más contenido en JavaScript, TypeScript u otros lenguajes.

Tu opinión define qué cursos vienen después y en qué tecnologías se profundiza. Si algo te hizo ruido, dilo. Si algo te voló la cabeza, también.

Nos vemos en la siguiente aventura con los patrones estructurales. ¿Cuál fue el patrón creacional que más te costó entender? Cuéntalo en los comentarios.

Comentarios

Alvaro Eduardo Garzón Pira

Estudiante

Dani: "Sé que el camino no ha sido sencillo"
Inmediatamente yo después de caer en cuenta que no estuvo nada fácil el curso:

Diego Reyes Cabrera

Estudiante

Verdaderamente, no estuvo fácil... no es como otros cursos de la escuela, que te enseñan a hacer algo y dices Ah ok. En este tienes que pensar, analizar, comprender...

Alvaro Eduardo Garzón Pira

Estudiante

Re leer, re leer, investigar... Siento que a pesar que pudo mejorar este curso con sus ejemplos y explicaciones, es una real joya oculta que rompe el paradigma de "platzi solo enseña lo básico, no profundiza en nada", es una real joya, ¡Falta ya el curso de patrones de diseño estructurales y de comportamiento!

Irving Juárez

Estudiante

Ya tenía rato que no tomaba un curso aquí en Platzi con tan buenos ejemplos y un excelente profesor. PD: Todavia seguimos esperando los siguientes cursos de esta serie de Patrones de Diseño.

Daniel Basulto

Profesor

Estan cocinandose, trabajamos que pronto haya noticias, gracias Irving!

Julio César Cid

Estudiante

Más cursos como este porfavor, en donde se explica con código y ejemplos claros el uso de patrones de diseño.

Daniel Basulto

Profesor

Esta en los planes Julio, el feedback ha sido muy muy bueno!

Ulqernesh Karvenae

Estudiante

Excelente curso, en espera de los próximos dos como recomendación me gustaria que explicara mas ejemplos, si esta bien centrarse en uno para mantener el foco en el código por que no muestras otros casos de uso o en los mismos retos en vez de ser retos relacionados con el ejemplo dado por que no que los retos sean random sean otras situaciones y con eso no pensamos en extender lo que se explico sino en como lo puedo aplicar a esta situación,

Daniel Basulto

Profesor

Gracias por el feedback, anotado!

Elmer Jean Pierre Alpiste Ramírez

Estudiante

En qué ruta estaría esta serie de cursos? Que está genial por cierto.

Daniel Basulto

Profesor

Muchas gracias Elmer. Una disculpa por la respuesta tardía.

Estara en la ruta futura de arquitectura y diseño de software.

Jonathan David Olivos

Estudiante

Es una lástima que los otros cursos nunca vieron la luz

N40 M10

Estudiante

Esperando a los próximos cursos, espero sobre todo a los observer.

Daniel Basulto

Profesor

Se esta cocinando una planificacion ambiciosa para las siguientes categorias :)

N40 M10

Estudiante

Maravilloso!!

Xavier Flores

Estudiante

queremos más cursos de patrones jjj! Excelente curso

Daniel Basulto

Profesor

Seguimos con ello Xavi, gracias!

Hiram Rodriguez Gomez

Estudiante

Excelente serie de cursos, me los recomendaron y fue un tip muy bueno.

A la espera de los siguientes cursos, y probablemente, le daré un repaso extra a estas clases para poder reafirmar mejor estos conocimientos.

Daniel Basulto

Profesor

Excelente Hiram, gracias por tus comentarios!

Johan Sebastian

Estudiante

Necesitan explicar un poco mas de donde sale cada cosa y porque se crea, tambien dar mas ejemplo de como sale cada constructor

Ana Rotela Cabrera

Estudiante

Aprendí muchísimo, lo único es que me gustaría otro curso práctico, este tuvo buenos ejemplos pero me gustaría profundizar con ejemplos que pudieramos usar y asi continuar mejorando.

FABULOSO es el profesor Daniel

Luis Eduardo Payano Villar

Estudiante

class baseCar{
    showCosts(){
    throw new Error('method not implemented');
    }
}

class ElectricCar extends baseCar{
    showCosts(){
        console.log('Costos de un coche eléctrico 150,000 us');
    }
}

class HybridCar extends baseCar{
    showCosts(){
        console.log('Costos de un coche híbrido 30,000 us');
    }
}

class Car extends baseCar{
    showCosts(){
        console.log('Costos de un coche convencional 25,000 us');
    }
}


class factoryCar {
    makeCar(){
        throw new Error('method not implemented');
    }
}


class ElectricCarFactory extends factoryCar{
    makeCar(){
        return new ElectricCar();
    }
}

class HybridCarFactory extends factoryCar{
    makeCar(){
        return new HybridCar();
    }
}

class SingleCarFactory extends factoryCar{
    makeCar(){
        return new Car();
    }
}



function appCarFactory(factory){
    const car = factory.makeCar();
    car.showCosts();
    //... otros métodos y propiedades del coche
}

//appFactory(new HybridCarFactory());
//appFactory(new ElectricCarFactory());
//appFactory(new SingleCarFactory());


function CreateFactory(type){
    const factories = {
        Electric: ElectricCarFactory,
        Hybrid: HybridCarFactory,
        Default: SingleCarFactory
    };

    const Factory = factories[type];

    return new Factory();
}

appCarFactory(CreateFactory('Electric'));
appCarFactory(CreateFactory('Hybrid'));
appCarFactory(CreateFactory('Default'
```class baseCar{    showCosts(){    throw new Error('method not implemented');    }}
class ElectricCar extends baseCar{    showCosts(){        console.log('Costos de un coche eléctrico 150,000 us');    }}
class HybridCar extends baseCar{    showCosts(){        console.log('Costos de un coche híbrido 30,000 us');    }}
class Car extends baseCar{    showCosts(){        console.log('Costos de un coche convencional 25,000 us');    }}

class factoryCar {    makeCar(){        throw new Error('method not implemented');    }}

class ElectricCarFactory extends factoryCar{    makeCar(){        return new ElectricCar();    }}
class HybridCarFactory extends factoryCar{    makeCar(){        return new HybridCar();    }}
class SingleCarFactory extends factoryCar{    makeCar(){        return new Car();    }}


function appCarFactory(factory){    const car = factory.makeCar();    car.showCosts();    //... otros métodos y propiedades del coche}
//appFactory(new HybridCarFactory());//appFactory(new ElectricCarFactory());//appFactory(new SingleCarFactory());

function CreateFactory(type){    const factories = {        Electric: ElectricCarFactory,        Hybrid: HybridCarFactory,        Default: SingleCarFactory    };
    const Factory = factories\[type];
    return new Factory();}
appCarFactory(CreateFactory('Electric'));appCarFactory(CreateFactory('Hybrid'));appCarFactory(CreateFactory('Default'

Luis Eduardo Payano Villar

Estudiante

class singletons{
    static instance = undefined;
    //Atributo estático para almacenar el valor, llamado para la validación de getInstance() 

    constructor(version){
        this.version = version;
    }


    static getInstance(version){
           //Si no existe el atributo instance...
        if(!singletons.instance){
            singletons.instance = new singletons(version); //...lo crea. 
        }
        return singletons.instance;
    }
}

function appSingletons(){
      /*Todas las variables tienen la misma referencia al mismo objeto. 1 sola instancia 
      a lo largo de la aplicación:*/
    const singleton1 = singletons.getInstance('singletons-v1');
    const singleton2 = singletons.getInstance('singletons-v2');
    const singleton3 = singletons.getInstance('singletons-v3');

      console.log(singleton1 === singleton2);
      console.log(singleton1 === singleton3);
}

appSingletons();
```class singletons{    static instance = undefined;    //Atributo estático para almacenar el valor, llamado para la validación de getInstance()&#x20;
    constructor(version){        this.version = version;    }

    static getInstance(version){           //Si no existe el atributo instance...        if(!singletons.instance){            singletons.instance = new singletons(version); //...lo crea.         }        return singletons.instance;    }}
function appSingletons(){      /\*Todas las variables tienen la misma referencia al mismo objeto. 1 sola instancia       a lo largo de la aplicación:\*/    const singleton1 = singletons.getInstance('singletons-v1');    const singleton2 = singletons.getInstance('singletons-v2');    const singleton3 = singletons.getInstance('singletons-v3');
      console.log(singleton1 === singleton2);      console.log(singleton1 === singleton3);}
appSingletons();

Jorge Paiva

Estudiante

Bien el curso!

Seria genial tambien en C# comparando con JAVA :-)

Ulqernesh Karvenae

Estudiante

Harold Zurita Simon

Estudiante

Excelente curso! 😄 Fueron temas muy interesantes y el contraste con TS ha sido increíble. . Espero con entusiasmo la continuación. Hasta una próxima ocasión 👋.

Daniel Basulto

Profesor

Gracias Harold!!

class baseCar{
    showCosts(){
    throw new Error('method not implemented');
    }
}

class ElectricCar extends baseCar{
    showCosts(){
        console.log('Costos de un coche eléctrico 150,000 us');
    }
}

class HybridCar extends baseCar{
    showCosts(){
        console.log('Costos de un coche híbrido 30,000 us');
    }
}

class Car extends baseCar{
    showCosts(){
        console.log('Costos de un coche convencional 25,000 us');
    }
}


class factoryCar {
    makeCar(){
        throw new Error('method not implemented');
    }
}


class ElectricCarFactory extends factoryCar{
    makeCar(){
        return new ElectricCar();
    }
}

class HybridCarFactory extends factoryCar{
    makeCar(){
        return new HybridCar();
    }
}

class SingleCarFactory extends factoryCar{
    makeCar(){
        return new Car();
    }
}



function appCarFactory(factory){
    const car = factory.makeCar();
    car.showCosts();
    //... otros métodos y propiedades del coche
}

//appFactory(new HybridCarFactory());
//appFactory(new ElectricCarFactory());
//appFactory(new SingleCarFactory());


function CreateFactory(type){
    const factories = {
        Electric: ElectricCarFactory,
        Hybrid: HybridCarFactory,
        Default: SingleCarFactory
    };

    const Factory = factories[type];

    return new Factory();
}

appCarFactory(CreateFactory('Electric'));
appCarFactory(CreateFactory('Hybrid'));
appCarFactory(CreateFactory('Default'
```class baseCar{    showCosts(){    throw new Error('method not implemented');    }}
class ElectricCar extends baseCar{    showCosts(){        console.log('Costos de un coche eléctrico 150,000 us');    }}
class HybridCar extends baseCar{    showCosts(){        console.log('Costos de un coche híbrido 30,000 us');    }}
class Car extends baseCar{    showCosts(){        console.log('Costos de un coche convencional 25,000 us');    }}

class factoryCar {    makeCar(){        throw new Error('method not implemented');    }}

class ElectricCarFactory extends factoryCar{    makeCar(){        return new ElectricCar();    }}
class HybridCarFactory extends factoryCar{    makeCar(){        return new HybridCar();    }}
class SingleCarFactory extends factoryCar{    makeCar(){        return new Car();    }}


function appCarFactory(factory){    const car = factory.makeCar();    car.showCosts();    //... otros métodos y propiedades del coche}
//appFactory(new HybridCarFactory());//appFactory(new ElectricCarFactory());//appFactory(new SingleCarFactory());

function CreateFactory(type){    const factories = {        Electric: ElectricCarFactory,        Hybrid: HybridCarFactory,        Default: SingleCarFactory    };
    const Factory = factories\[type];
    return new Factory();}
appCarFactory(CreateFactory('Electric'));appCarFactory(CreateFactory('Hybrid'));appCarFactory(CreateFactory('Default'

class singletons{
    static instance = undefined;
    //Atributo estático para almacenar el valor, llamado para la validación de getInstance() 

    constructor(version){
        this.version = version;
    }


    static getInstance(version){
           //Si no existe el atributo instance...
        if(!singletons.instance){
            singletons.instance = new singletons(version); //...lo crea. 
        }
        return singletons.instance;
    }
}

function appSingletons(){
      /*Todas las variables tienen la misma referencia al mismo objeto. 1 sola instancia 
      a lo largo de la aplicación:*/
    const singleton1 = singletons.getInstance('singletons-v1');
    const singleton2 = singletons.getInstance('singletons-v2');
    const singleton3 = singletons.getInstance('singletons-v3');

      console.log(singleton1 === singleton2);
      console.log(singleton1 === singleton3);
}

appSingletons();
```class singletons{    static instance = undefined;    //Atributo estático para almacenar el valor, llamado para la validación de getInstance()&#x20;
    constructor(version){        this.version = version;    }

    static getInstance(version){           //Si no existe el atributo instance...        if(!singletons.instance){            singletons.instance = new singletons(version); //...lo crea.         }        return singletons.instance;    }}
function appSingletons(){      /\*Todas las variables tienen la misma referencia al mismo objeto. 1 sola instancia       a lo largo de la aplicación:\*/    const singleton1 = singletons.getInstance('singletons-v1');    const singleton2 = singletons.getInstance('singletons-v2');    const singleton3 = singletons.getInstance('singletons-v3');
      console.log(singleton1 === singleton2);      console.log(singleton1 === singleton3);}
appSingletons();

Introduccion

Patrones creacionales en diseño de software

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

Singleton

Patrón Singleton: una sola instancia

Diagrama de Clases del Patrón Singleton en JavaScript

Singleton en TypeScript vs JavaScript

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

Factory

Patrones de Diseño: Introducción al Patrón Factory

Diagrama UML del patrón Factory

Implementación del Patrón Factory Method en JavaScript

Factory en TypeScript vs JavaScript

Patrón Factory: Ventajas y Desventajas en Desarrollo de Software

Abstract Factory

Qué es el patrón Abstract Factory

Patrones de Diseño: Abstract Factory en Producción de Coches

Implementación del patrón Abstract Factory en JavaScript

Diferencias entre JavaScript y TypeScript en el patrón Abstract Factory

Patrón Abstract Factory: Ventajas y Desventajas

Builder

Patrón Builder para crear objetos complejos

Patrón Builder: Análisis de Diagrama y Clases Relacionadas

Implementación del Patrón Builder en Producción de Coches

Comparación del Patrón Builder en JavaScript vs TypeScript

Patrón Builder: Ventajas, Desventajas y Aplicaciones Prácticas

Prototype

Patrón Prototype: Clonación de Objetos en Diseño de Software

Diagrama UML del patrón Prototype explicado

Implementación del Patrón Prototype en JavaScript

Comparación de Prototype en JavaScript y TypeScript

Patrón Prototype: Ventajas y Desafíos en Diseño de Software

Conclusiones

Qué aprendiste con patrones creacionales

Resumen