All posts

Principios SOLID con Nodejs

Los principios SOLID son fundamentales para el diseño de software orientado a objetos, y se aplican también a Node.js.

Los principios SOLID son fundamentales para el diseño de software orientado a objetos, y se aplican también a Node.js.
Video preview
Estos principios ayudan a los desarrolladores a escribir código que sea mantenible, flexible y robusto. Al seguir estos principios, los desarrolladores pueden evitar muchos problemas comunes de diseño de software.
  1. Principio de responsabilidad única (SRP): Este principio establece que una clase debe tener solo un fin en especifico. En Node.js, esto podría implicar la creación de módulos separados para cada funcionalidad.
// user.js
module.exports = class User {
    constructor(name, email) {
        this.name = name;
        this.email = email;
    }
};

// emailer.js
const nodemailer = require('nodemailer');
module.exports = class Emailer {
    constructor(user) {
        this.user = user;
    }
    sendEmail() {
        // código para enviar correo electrónico
    }
};
  1. Principio de abierto/cerrado (OCP): Este principio establece que las entidades de software deben estar abiertas para la extensión, pero cerradas para la modificación. En Node.js, esto podría implicar el uso de herencia y clases base.
// baseRepository.js
module.exports = class BaseRepository {
    save(object) {
        // código para salvar objeto
    }
};

// userRepository.js
const BaseRepository = require('./baseRepository.js');
module.exports = class UserRepository extends BaseRepository {
    // código adicional específico para User
};
  1. Principio de sustitución de Liskov (LSP): Este principio establece que las subclases deben ser intercambiables por sus clases base. En Node.js, esto podría implicar el uso de polimorfismo y herencia.
// animal.js
module.exports = class Animal {
    makeSound() {
        // código para hacer sonido
    }
};

// dog.js
const Animal = require('./animal.js');
module.exports = class Dog extends Animal {
    makeSound() {
        // código para ladrar
    }
};
  1. Principio de segregación de interfaces (ISP): Este principio establece que las clases no deben ser forzadas a implementar interfaces que no utilizan. En Node.js, esto podría implicar el uso de clases más pequeñas y específicas en lugar de una gran clase monolítica.
// iFly.js
module.exports = class IFly {
    fly() {
        // código para volar
    }
};

// iWalk.js
module.exports = class IWalk {
    walk() {
        // código para caminar
    }
};

// bird.js
const IFly = require('./iFly.js');
module.exports = class Bird extends IFly {
    // Bird solo necesita implementar la interfaz de vuelo
};
  1. Principio de inversión de dependencias (DIP): Este principio establece que debemos depender de abstracciones, no de concreciones. En Node.js, esto podría implicar el uso de inyección de dependencias y el principio de "Inversión de Control".
// iDatabase.js
module.exports = class IDatabase {
    save() {
        // código para guardar
    }
};

// userRepository.js
module.exports = class UserRepository {
    constructor(database) {
        this.database = database;
    }
    saveUser(user) {
        this.database.save(user);
    }
};