Introducción a SRP:
El Principio de Responsabilidad Única (SRP) es uno de los cinco principios SOLID, un conjunto de pautas para escribir código más limpio y sostenible. SRP establece que una clase debe tener sólo una razón para cambiar, lo que significa que debe tener sólo una responsabilidad o función. Seguir este principio hace que el código sea más fácil de entender, mantener y probar.

Objetivos del SRP:

• Mantenimiento simplificado: Dado que las clases tienen una sola responsabilidad, identificar y corregir errores se vuelve más fácil.
• Responsabilidad clara: Cada clase tiene un propósito claro, lo que hace que el código sea más fácil de entender.
• Capacidad de prueba mejorada: Las clases con responsabilidades únicas son más fáciles de aislar y probar.
• Facilidad de cambio: Los cambios en una responsabilidad específica no afectan otras partes del sistema.

Ejemplo de malas prácticas (Clases):
Aquí tenemos una clase UserService que hace más de una cosa: administra usuarios y envía notificaciones.

class UserService {
  createUser(user: User): void {
    // Logic to create user
  }

  deleteUser(userId: string): void {
    // Logic to delete user
  }

  notifyUser(userId: string, message: string): void {
    // Logic to notify user
  }
}

En este enfoque, la clase UserService tiene múltiples responsabilidades: administrar usuarios y enviar notificaciones. Esto viola el SRP.

Ejemplo de buenas prácticas (Clases):
Para aplicar SRP, podemos separar las responsabilidades en distintas clases.

class UserService {
  createUser(user: User): void {
    // Logic to create user
  }

  deleteUser(userId: string): void {
    // Logic to delete user
  }
}

class NotificationService {
  notifyUser(userId: string, message: string): void {
    // Logic to notify user
  }
}

Ahora, UserService maneja solo la creación y eliminación de usuarios, mientras que NotificationService maneja las notificaciones. Cada clase tiene una única responsabilidad, siguiendo el SRP.

Ejemplo de mala práctica (Funciones):
Aquí tenemos una función que hace más de una cosa: crea un usuario y envía una notificación.

function createUserAndNotify(user: User, message: string): void {
  // Logic to create user
  // Logic to send notification
}

En este enfoque, la función createUserAndNotify tiene múltiples responsabilidades: crear un usuario y enviar una notificación. Esto viola el SRP.

Ejemplo de buenas prácticas (funciones):
Para aplicar SRP, podemos separar las responsabilidades en distintas funciones.

function createUser(user: User): void {
  // Logic to create user
}

function notifyUser(userId: string, message: string): void {
  // Logic to notify user
}

// Using the separated functions
createUser(newUser);
notifyUser(newUser.id, 'Welcome!');

Ahora, la función createUser maneja solo la creación de usuarios, mientras que notifyUser maneja las notificaciones. Cada función tiene una única responsabilidad, siguiendo el SRP.

Aplicación en React Native con TypeScript:
Imaginemos que estamos desarrollando una aplicación de gestión de tareas. Podemos aplicar SRP separando la lógica de gestión de tareas y la lógica de notificación en diferentes clases.

Ejemplo de malas prácticas (Clases):

class TaskService {
  addTask(task: Task): void {
    // Logic to add task
  }

  removeTask(taskId: string): void {
    // Logic to remove task
  }

  notifyTaskDue(taskId: string): void {
    // Logic to notify that the task is due
  }
}

Ejemplo de buenas prácticas (Clases):

class TaskService {
  addTask(task: Task): void {
    // Logic to add task
  }

  removeTask(taskId: string): void {
    // Logic to remove task
  }
}

class TaskNotificationService {
  notifyTaskDue(taskId: string): void {
    // Logic to notify that the task is due
  }
}

Ejemplo de mala práctica (Funciones):

function addTaskAndNotify(task: Task): void {
  // Logic to add task
  // Logic to notify that the task is due
}

Ejemplo de buenas prácticas (funciones):

function addTask(task: Task): void {
  // Logic to add task
}

function notifyTaskDue(taskId: string): void {
  // Logic to notify that the task is due
}

// Using the separated functions
addTask(newTask);
notifyTaskDue(newTask.id);

Al dividir las responsabilidades, hacemos que la aplicación sea más fácil de mantener y expandir.

Conclusión:
Seguir el principio de responsabilidad única ayuda a mantener el código limpio, organizado y más fácil de mantener. La aplicación de SRP en el desarrollo de React Native con TypeScript da como resultado un código más modular y comprobable. Recuerda siempre mantener tus clases y funciones enfocadas en una sola responsabilidad para cosechar todos los beneficios de este principio.