Patrones de diseño: Métodos para un código escalable en JavaScript

El mundo del desarrollo de software es dinámico y exige soluciones eficientes y escalables. En el contexto de JavaScript, lenguaje predominante en el desarrollo web, adoptar patrones de diseño no solo es recomendable, sino necesario para construir aplicaciones robustas y fáciles de mantener. A continuación, exploraremos algunos patrones de diseño cruciales y cómo aplicarlos en JavaScript para resolver problemas comunes de programación, mejorando así la calidad del código y la productividad del desarrollador.

Patrón Módulo: Encapsulamiento y Organización

El patrón de diseño de Módulo es uno de los más utilizados en JavaScript debido a su capacidad para crear encapsulación y mantener separados los segmentos de código. Este patrón es esencial para evitar colisiones en el espacio de nombres y proteger variables y funciones como privadas. A continuación se presenta un ejemplo de cómo implementar el patrón de Módulo en JavaScript:

var MiModulo = (function() {
    var variablePrivada = 'Soy una variable privada';
    function funcionPrivada() {
        console.log('Accedido a función privada');
    }

    return {
        funcionPublica: function() {
            console.log('Accedido a función pública');
        }
    };
})();

console.log(MiModulo.variablePrivada); // undefined
MiModulo.funcionPublica(); // 'Accedido a función pública'

Patrón Observador: Comunicación entre objetos

El patrón Observador permite crear un mecanismo de suscripción para que múltiples objetos 'escuchen' y reaccionen a eventos o cambios en otro objeto. Es muy útil en aplicaciones donde la actualización en tiempo real es crítica, como interfaces de usuario o juegos. Implementemos una versión simplificada de este patrón en JavaScript:

function Observador() {
    this.subscriptores = [];
}

Observador.prototype = {
    suscribir: function(fn) {
        this.subscriptores.push(fn);
    },
    notificar: function(data) {
        this.subscriptores.forEach(subscriptor => subscriptor(data));
    }
};

// Uso:
var miObservador = new Observador();
miObservador.suscribir(datos => console.log('Suscriptor 1 recibió datos:', datos));
miObservador.notificar('Hola Mundo!');

Patrón Singleton: Una única instancia

El patrón Singleton garantiza que una clase tenga una única instancia y provee un punto de acceso global a ella. Este patrón es útil cuando se necesita controlar estrictamente cómo y cuándo se accede a ciertos recursos compartidos, como conexiones a bases de datos. Veamos cómo implementar el patrón Singleton en JavaScript:

var Singleton = (function() {
    var instancia;
    function crearInstancia() {
        var objeto = new Object('Instancia única');
        return objeto;
    }

    return {
        obtenerInstancia: function() {
            if (!instancia) {
                instancia = crearInstancia();
            }
            return instancia;
        }
    };
})();

var instancia1 = Singleton.obtenerInstancia();
var instancia2 = Singleton.obtenerInstancia();

console.log(instancia1 === instancia2);  // true

Patrón Estrategia: Flexibilidad de algoritmos

El patrón Estrategia propone definir una familia de algoritmos, encapsular cada uno de ellos y hacerlos intercambiables. Este patrón permite que los algoritmos varíen independientemente de los clientes que los usan. Ejemplo de cómo aplicar el patrón Estrategia en JavaScript:

function EstrategiaDePago() {}
EstrategiaDePago.prototype.pagar = function(cantidad) {};

function PayPal() {}
PayPal.prototype = Object.create(EstrategiaDePago.prototype);
PayPal.prototype.pagar = function(cantidad) {
    console.log('Pagando ' + cantidad + ' utilizando PayPal.');
};

function TarjetaCredito() {}
TarjetaCredito.prototype = Object.create(EstrategiaDePago.prototype);
TarjetaCredito.prototype.pagar = function(cantidad) {
    console.log('Pagando ' + cantidad + ' utilizando Tarjeta de Crédito.');
};

var paypal = new PayPal();
paypal.pagar(50);

Patrón Cadena de Responsabilidades: Desacoplar emisores y receptores

El patrón Cadena de Responsabilidades ayuda a desacoplar el emisor de una solicitud de sus receptores, dando a más de un objeto la posibilidad de tratar la solicitud. Se vinculan los objetos receptores y pasan la solicitud a lo largo de la cadena hasta que es procesada por algún objeto. Implementación en JavaScript:

function Manejador() {
    this.sucesor = null;
}

Manejador.prototype = {
    establecerSucesor: function(sucesor) {
        this.sucesor = sucesor;
    },
    manejar: function(solicitud) {
        if (this.sucesor) {
            this.sucesor.manejar(solicitud);
        }
    }
};

// Uso:
var manejador1 = new Manejador();
var manejador2 = new Manejador();
manejador1.establecerSucesor(manejador2);
manejador1.manejar('solicitud');

Te puede interesar

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *