¿Cómo implementar el patrón AbstractFactory en JavaScript?

El patrón AbstractFactory es una robusta herramienta para la creación de familias de objetos relacionados. En este artículo, presentamos la implementación práctica de este patrón orientado a objetos en JavaScript, destacando su poder para disminuir el acoplamiento entre el código cliente y las instancias de los productos.

¿Cómo definir las clases base de los productos?

Para arrancar con el AbstractFactory, es fundamental definir las clases o interfaces de los productos base. En este caso, definimos dos productos: Mastodon y Rhino. Cada producto implementa un método useGPS, lo que garantiza que las implementaciones futuras deban realizar este método.

fullscreen
class MastodonCard {
    useGPS() {
        throw new Error("method not implemented");
    }
}

class RhinoCard {
    useGPS() {
        throw new Error("method not implemented");
    }
}

¿Cómo creamos las clases concretas de los productos?

El siguiente paso es establecer las clases concretas de los productos, que heredan de las clases base. Aquí creamos dos familias de vehículos: Sedan y Hatchback. Cada familia tiene su correspondiente implementación para Mastodon y Rhino.

fullscreen
class MastodonSedanCard extends MastodonCard {
    useGPS() {
        console.log("Sedan Mastodon GPS");
    }
}

class RhinoSedanCard extends RhinoCard {
    useGPS() {
        console.log("Sedan Rhino GPS");
    }
}

// Implementaciones similares para Hatchback

¿Qué es el abstract factory?

Posteriormente, se define el abstract factory, que establece un contrato para la creación de nuestras instancias de producto.

fullscreen
class AbstractFactory {
    createMastodon() {
        throw new Error("method not implemented");
    }

    createRhino() {
        throw new Error("method not implemented");
    }
}

¿Cómo implementar las fábricas concretas?

La clave del patrón está en las fábricas concretas que heredan del abstract factory. Definen las específicas versiones de los productos dentro de una familia.

fullscreen
class SedanCarFactory extends AbstractFactory {
    createMastodon() {
        return new MastodonSedanCard();
    }

    createRhino() {
        return new RhinoSedanCard();
    }
}

// Implementación similar para Hatchback

¿Cómo utilizar el patrón abstract factory?

Al emplear el patrón AbstractFactory, se inyecta la fábrica deseada, permitiendo crear objetos sin conocer su precisa clase. En el siguiente ejemplo utilizamos la fábrica Sedan y la Hatchback, y llamamos al método useGPS() de modo genérico.

fullscreen
function appCarFactory(factory) {
    const mastodon = factory.createMastodon();
    const rhino = factory.createRhino();

    mastodon.useGPS();
    rhino.useGPS();
}

const sedanFactory = new SedanCarFactory();
appCarFactory(sedanFactory);

const hatchbackFactory = new HatchbackCarFactory();
appCarFactory(hatchbackFactory);

¿Qué podemos concluir sobre la implementación en JavaScript?

Esta implementación del patrón AbstractFactory demuestra cómo se pueden crear distintos tipos de objetos relacionados sin comprometer el código cliente con clases específicas. Este patrón facilita que el diseño del software sea flexible, manejable y extensible.

Comparación con TypeScript y otras consideraciones

En proyectos complejos, utilizar TypeScript puede ofrecer ventajas adicionales, como la verificación temprana de tipos que ayudan a detectar errores. Continuaremos explorando las particularidades y beneficios de implementar este patrón en TypeScript en futuras entregas.

Esta metodología no sólo ilustra un claro entendimiento de los patrones de diseño, sino que también se erige como una herramienta esencial en el arsenal de cualquier desarrollador. Te animo a que implementes este patrón en tus propios proyectos y descubras por ti mismo sus beneficios. ¡Continúa aprendiendo y mejorando tus habilidades!