➿Principio DRY

El principio DRY, acrónimo de "Don't Repeat Yourself" (No te Repitas), es un concepto fundamental en el desarrollo de software que enfatiza la reducción de la duplicación en el código. La idea detrás de DRY es que cada pieza de conocimiento en un sistema debe tener una única, inequívoca y autoritativa representación dentro de dicho sistema.

Objetivos Principales del Principio DRY:

1. Evitar la Redundancia: Asegurarse de que no hay bloques de código idénticos o muy similares en diferentes partes del sistema. Si una pieza de lógica necesita cambiar, solo debería necesitar ser actualizada en un lugar, reduciendo el riesgo de inconsistencias y errores.

2. Facilitar el Mantenimiento: Al tener una sola representación de cada pieza de conocimiento, el mantenimiento y la actualización del código se simplifican, ya que solo hay un lugar donde hacer cambios.

3. Mejorar la Claridad: El código sin duplicaciones es generalmente más fácil de entender y de seguir. Esto hace que sea más sencillo para los desarrolladores, tanto para los creadores originales como para los nuevos en el proyecto, trabajar con el código.

4. Optimizar la Reutilización: Fomentar la reutilización de código a través de funciones, módulos, clases, y otros mecanismos de abstracción que encapsulan comportamientos o lógicas que se repiten.

🧱 Clase Básica sin Aplicar DRY

class Product {
    constructor(public name: string, public price: number = 0, public size: string = '') {}

    toString() {
        if (!this.name) throw new Error("name is empty");
        if (!this.price) throw new Error("price is zero");
        if (!this.size) throw new Error("size is empty");
        return `${this.name} - $${this.price}, Size: ${this.size}`;
    }
}

🔄 Refactorización para Cumplir con DRY

    constructor(public name: string = '', public price: number = 0, public size: string = '') {}

    private validateProperty(property: any, propertyName: string): void {
        switch (typeof property) {
            case 'string':
                if (property.length === 0) {
                    throw new Error(`${propertyName} is empty`);
                }
                break;
            case 'number':
                if (property <= 0) {
                    throw new Error(`${propertyName} is zero or negative`);
                }
                break;
                //Los demas case para cada tipo soportado
            default:
                throw new Error(`Type of ${propertyName} is not supported for validation`);
        }
    }

    isProductReady(): boolean {
        this.validateProperty(this.name, 'name');
        this.validateProperty(this.price, 'price');
        this.validateProperty(this.size, 'size');
        return true;
    }

    toString(): string {
        if (!this.isProductReady()) return "Product is not ready";
        return `${this.name} - $${this.price}, Size: ${this.size}`;
    }
}

Otro Ejemplo :

🧱 Funciones sin aplicar DRY

function discountForBooks(quantity, price) {
    let discount = 0.1; // 10% de descuento para libros
    return quantity * price - quantity * price * discount;
}

function discountForGames(quantity, price) {
    let discount = 0.15; // 15% de descuento para juegos
    return quantity * price - quantity * price * discount;
}

function discountForClothes(quantity, price) {
    let discount = 0.2; // 20% de descuento para ropa
    return quantity * price - quantity * price * discount;
}

🔄 Refactorización para Cumplir con DRY

function calculateDiscount(quantity, price, discountRate) {
    return quantity * price - quantity * price * discountRate;
}

// Uso de la función refactorizada
const booksDiscount = calculateDiscount(10, 100, 0.1); // 10 libros a $100 cada uno con 10% de descuento
const gamesDiscount = calculateDiscount(5, 60, 0.15); // 5 juegos a $60 cada uno con 15% de descuento
const clothesDiscount = calculateDiscount(3, 50, 0.2); // 3 prendas de ropa a $50 cada una con 20% de descuento