Índice
Contents
Índice ...........................................................................................2
1. Introducción ...............................................................................4
1.1. Objetivo del Manual ...............................................................4
1.2. Descripción General del Proyecto.............................................4
1.3. Audiencia y Prerrequisitos ......................................................5
2. Requerimientos del Proyecto ........................................................5
2.1. Requerimientos Funcionales ...................................................5
2.1.1. Gestión de Préstamos.......................................................5
2.1.2. Registro y Consulta de Datos ............................................6
2.2. Requerimientos No Funcionales ...............................................7
2.2.1. Uso de la Consola ............................................................7
2.2.2. Persistencia de Datos con JSON .........................................7
3. Diseño y Estructura del Programa .................................................8
3.1. Arquitectura General del Proyecto ...........................................8
3.2. Organización del Código y Estructura de Archivos .................... 10
3.3. Descripción de Módulos y Funcionalidades .............................. 11
3.3.1. Módulo de Gestión de Préstamos ..................................... 11
3.3.2. Módulo de Persistencia (Uso de JSON) .............................. 12
3.3.3. Módulo de Interfaz de Usuario (Menús y Consola) .............. 13
3.3.4. Módulo de Validaciones y Utilidades ................................. 14
4. Interacción con el Usuario y Ejemplos de Menús ........................... 14
4.1. Diseño del Menú Principal ..................................................... 15
4.2. Submenús y Opciones del Sistema ........................................ 16
4.3. Ejemplos de Salidas y Mensajes en Consola ............................ 18
5. Persistencia de Datos con JSON .................................................. 19
5.1. Estructura de Datos: Lista de Diccionarios .............................. 19
5.2. Funciones de Guardado y Carga de Datos............................... 21
5.2.1. Función para Guardar Datos ............................................ 21
5.2.2. Función para Cargar Datos .............................................. 22
5.3. Consideraciones y Buenas Prácticas ....................................... 23
6. Introducción a Git en el Proyecto ................................................ 24
6.1. Importancia del Control de Versiones ..................................... 25
6.2. Inicialización del Repositorio ................................................. 25
6.3. Comandos Básicos............................................................... 26
6.4. Flujo de Trabajo Sugerido y Buenas Prácticas ......................... 28
6.5. Resolución de Conflictos y Mantenimiento del Historial ............. 29
1. Introducción
1.1. Objetivo del Manual
El propósito de este manual es guiar a los estudiantes en el desarrollo de
un programa básico de gestión de préstamos utilizando Python. El manual
está diseñado para:
Aplicar conocimientos previos de Python: Los alumnos utilizarán
estructuras de datos como listas y diccionarios, manejo de archivos y
funciones.
Introducir conceptos de persistencia de datos: Se enseñará cómo utilizar
el módulo json para almacenar y recuperar la información de forma
permanente.
Fomentar el uso de control de versiones: Se introducirán los conceptos
básicos de Git, lo cual permitirá a los estudiantes aprender a gestionar y
documentar el desarrollo de su código de forma colaborativa y ordenada.
1.2. Descripción General del Proyecto
El proyecto consiste en crear una aplicación de consola que permita
gestionar préstamos de forma básica. Las principales características del
proyecto son:
Interfaz de Usuario en Consola: La interacción se realizará a través de
menús y opciones presentados en la terminal.
Manejo de Datos con Estructuras Nativas: Los datos se almacenarán en
una lista de diccionarios, donde cada diccionario representará un registro
de préstamo con campos como identificador, nombre del prestatario,
monto, fecha de préstamo, entre otros.
Persistencia de Datos: Se utilizará el módulo json de Python para guardar
la información en un archivo, permitiendo la persistencia de los datos
entre ejecuciones del programa.
Modularidad del Código: El proyecto se organizará en varios módulos
(gestión de préstamos, persistencia de datos, interfaz de usuario,
utilidades) para promover una buena organización y mantenimiento del
código.
Integración con Git: Se incorporarán prácticas básicas de Git para que los
estudiantes aprendan a gestionar versiones, realizar commits y colaborar
de forma ordenada.
1.3. Audiencia y Prerrequisitos
Este manual está dirigido a estudiantes que:
Han completado un curso básico de Python: Se espera que conozcan la
sintaxis, estructuras de datos (listas, diccionarios), manejo de archivos y
conceptos básicos de programación.
Tienen interés en aprender sobre control de versiones: Aunque algunos
pueden no haber usado Git anteriormente, el manual incluirá una
introducción a sus comandos y flujo de trabajo.
Cuentan con nociones básicas de terminal o línea de comandos: La
interacción con el programa y Git se realizará desde la consola, por lo que
es importante que se sientan cómodos utilizando comandos básicos en la
terminal.
2. Requerimientos del Proyecto
2.1. Requerimientos Funcionales
2.1.1. Gestión de Préstamos
El programa debe permitir la administración integral de los préstamos, lo
que incluye las siguientes funcionalidades:
Agregar Nuevo Préstamo:
Permitir al usuario ingresar un nuevo registro de préstamo, solicitando los
datos necesarios (por ejemplo: identificador único, nombre del
prestatario, monto del préstamo, fecha del préstamo, y otros datos
relevantes).
Modificar Préstamo Existente:
Posibilitar la edición de la información de un préstamo ya registrado. Esto
puede incluir la actualización del estado del préstamo (activo, devuelto,
vencido) o la modificación de otros datos.
Eliminar Préstamo:
Ofrecer la opción de borrar un registro de préstamo, en caso de que se
haya ingresado de manera incorrecta o el préstamo ya no sea relevante.
Consultar Préstamos:
Facilitar la visualización de todos los préstamos registrados. Además, se
deberá permitir realizar búsquedas por criterios específicos (por ejemplo,
por nombre del prestatario o por identificador).
2.1.2. Registro y Consulta de Datos
El sistema debe gestionar de manera eficiente el registro y la consulta de
los datos, cumpliendo con los siguientes requerimientos:
Registro Completo:
Al crear o modificar un préstamo, el programa debe solicitar todos los
datos requeridos para un registro completo y consistente.
Visualización Clara:
La información registrada debe mostrarse de forma organizada en la
consola, permitiendo al usuario identificar rápidamente cada campo del
préstamo.
Filtros y Búsquedas:
Implementar opciones de filtrado o búsqueda para que el usuario pueda
encontrar rápidamente un préstamo específico, por ejemplo, buscando
por nombre o identificador.
2.2. Requerimientos No Funcionales
2.2.1. Uso de la Consola
Interfaz Basada en Texto:
El programa se ejecutará en la terminal o consola, por lo que la interacción
se realizará mediante menús y mensajes impresos en pantalla.
Facilidad de Uso:
Los menús y opciones deben estar diseñados de manera intuitiva, de
forma que incluso usuarios con poca experiencia en interfaces de línea de
comandos puedan navegar y utilizar el sistema sin dificultad.
Respuesta Inmediata:
Las acciones ejecutadas por el usuario (como agregar, modificar o
eliminar un préstamo) deben dar una respuesta inmediata en la consola,
confirmando el éxito o señalando errores.
2.2.2. Persistencia de Datos con JSON
Almacenamiento Estructurado:
La base de datos del proyecto será una lista de diccionarios. Cada
diccionario contendrá la información de un préstamo, estructurada en
campos clave-valor.
Uso del Módulo json:
Se utilizará el paquete json para serializar la lista de diccionarios y
guardarla en un archivo. De igual forma, se implementarán funciones para
leer el archivo JSON al inicio del programa y cargar los datos en memoria.
Integridad de los Datos:
Se deben implementar controles para asegurar que la información se
guarda de forma correcta y que, en caso de errores, se manejen
adecuadamente (por ejemplo, utilizando excepciones para la
lectura/escritura de archivos).
3. Diseño y Estructura del Programa
Este apartado describe cómo se organizará el proyecto, tanto en términos
de la arquitectura global del sistema como en la división del código en
módulos y archivos, facilitando su mantenimiento, escalabilidad y
comprensión.
3.1. Arquitectura General del Proyecto
El proyecto se basa en una arquitectura modular, donde cada componente
tiene una responsabilidad claramente definida. Se pueden identificar tres
componentes principales:
Lógica de Negocio (Gestión de Préstamos):
Aquí se implementan las operaciones centrales del sistema, como
agregar, modificar, eliminar y consultar préstamos. Este módulo
interactúa con la estructura en memoria (una lista de diccionarios) que
representa la base de datos.
Persistencia de Datos (Uso de JSON):
Este componente se encarga de la serialización y deserialización de la
información. Utilizando el módulo json de Python, los datos se guardarán
en un archivo y se cargarán al iniciar la aplicación, asegurando la
persistencia entre sesiones.
Interfaz de Usuario (Menús y Consola):
La comunicación con el usuario se realizará a través de una interfaz
basada en consola. Se mostrarán menús interactivos, se capturará la
entrada del usuario y se desplegarán mensajes informativos, de error o
confirmatorios.
El flujo general del programa es el siguiente:
Inicialización:
Al arrancar, el programa carga los datos existentes desde el archivo JSON
y los almacena en una lista de diccionarios.
Interacción con el Usuario:
Se muestra un menú principal en la consola que permite al usuario
seleccionar la acción deseada (agregar, modificar, eliminar, consultar).
Procesamiento de la Solicitud:
Según la opción elegida, se invoca la funcionalidad correspondiente del
módulo de gestión de préstamos.
Actualización y Persistencia:
Una vez procesada la solicitud, se actualiza la lista en memoria y se
guarda el estado actual en el archivo JSON.
Esta separación de responsabilidades permite modificar o ampliar cada
componente de forma independiente, lo que es fundamental para el
mantenimiento y la evolución del proyecto.
3.2. Organización del Código y Estructura de Archivos
Se recomienda organizar el proyecto en distintos módulos y carpetas para
mantener un código limpio y bien estructurado. A continuación, se
presenta una estructura sugerida:
main.py:
Archivo de entrada del programa. Se encarga de inicializar el sistema,
cargar los datos del archivo JSON y gestionar el flujo principal de la
aplicación.
gestion_prestamos.py:
Contiene la lógica para la administración de préstamos. Aquí se
implementarán funciones para agregar, modificar, eliminar y consultar
préstamos.
persistencia.py:
Se encarga de la persistencia de datos. Incluye funciones para guardar la
lista de diccionarios en un archivo JSON y para cargar estos datos al inicio
del programa. También implementa el manejo de errores en operaciones
de lectura/escritura.
interfaz.py:
Gestiona la interacción con el usuario. Incluye funciones para mostrar
menús, capturar entradas y desplegar mensajes en la consola de forma
clara y organizada.
utilidades.py:
Contiene funciones auxiliares y de validación que pueden ser utilizadas
por los demás módulos. Por ejemplo, funciones para validar la entrada de
datos, formatear fechas o generar identificadores únicos.
data/prestamos.json:
Archivo que actúa como base de datos persistente, almacenando los
registros de préstamos en formato JSON.
Esta organización modular favorece la reutilización del código, facilita el
trabajo colaborativo y permite escalar el proyecto de manera ordenada.
3.3. Descripción de Módulos y Funcionalidades
A continuación, se detalla cada uno de los módulos que compondrán el
sistema:
3.3.1. Módulo de Gestión de Préstamos
Responsabilidades:
Agregar Préstamo:
Función para crear un nuevo préstamo. Se solicita al usuario que ingrese
datos como identificador, nombre del prestatario, monto, fecha, entre
otros. Se debe validar que el identificador no se repita.
Modificar Préstamo:
Permite actualizar la información de un préstamo existente, ya sea
cambiando datos personales, el estado del préstamo (por ejemplo, activo,
devuelto) o cualquier otro campo relevante.
Eliminar Préstamo:
Función para eliminar un registro dado un identificador específico. Es
importante solicitar confirmación al usuario antes de proceder con la
eliminación.
Consultar Préstamos:
Funcionalidad que permite listar todos los préstamos registrados. Se
pueden implementar filtros para buscar por criterios específicos, como el
nombre del prestatario o el identificador.
Este módulo interactúa directamente con la estructura en memoria, que
es la lista de diccionarios, y se encarga de mantener la integridad de la
información.
3.3.2. Módulo de Persistencia (Uso de JSON)
Responsabilidades:
Guardar Datos:
Serializar la lista de diccionarios y escribirla en un archivo JSON. Es crucial
asegurarse de que la información se almacene de manera correcta y
segura.
Cargar Datos:
Leer el archivo JSON al inicio del programa y cargar los registros en la
estructura en memoria. Se debe manejar adecuadamente el caso en que
el archivo no exista o esté corrupto.
Manejo de Errores:
Implementar controles y excepciones para gestionar posibles fallos en las
operaciones de lectura y escritura, asegurando que el programa pueda
recuperarse o informar al usuario de manera clara.
Este módulo garantiza que la información persista entre ejecuciones y que
las operaciones de guardado y carga sean transparentes para los demás
componentes.
3.3.3. Módulo de Interfaz de Usuario (Menús y Consola)
Responsabilidades:
Mostrar Menú Principal:
Desplegar un menú interactivo en la consola con las opciones disponibles:
agregar, modificar, eliminar y consultar préstamos, entre otras posibles
funcionalidades.
Captura de Datos:
Solicitar al usuario los datos necesarios para cada operación, validando
que la entrada cumpla con el formato requerido (por ejemplo, asegurarse
de que se ingrese un número cuando sea necesario).
Mensajes y Salidas:
Proporcionar mensajes informativos, de confirmación o error, facilitando
la interacción y retroalimentación inmediata al usuario.
Navegación:
Permitir al usuario moverse entre diferentes opciones y submenús de
manera intuitiva, garantizando una experiencia fluida y sin
complicaciones.
Este módulo se encarga de la comunicación directa con el usuario,
haciendo que la experiencia de uso sea clara y amigable.
3.3.4. Módulo de Validaciones y Utilidades
Responsabilidades:
Validación de Datos:
Implementar funciones que verifiquen que los datos ingresados por el
usuario cumplen con los requisitos (por ejemplo, formato de fecha, que
el monto sea un valor numérico, etc.).
Generación de Identificadores Únicos:
Funciones que aseguren que cada préstamo registrado tenga un
identificador único, evitando conflictos en la base de datos.
Formateo de Salidas:
Funciones que mejoren la presentación de la información en la consola,
facilitando la lectura y comprensión de los datos mostrados.
Utilidades Generales:
Otras funciones auxiliares que pueden ser reutilizadas en distintos
módulos, ayudando a mantener el código limpio y modular.
Este módulo es fundamental para mantener la calidad y consistencia de
los datos, así como para facilitar la reutilización de código en todo el
proyecto.
4. Interacción con el Usuario y Ejemplos de Menús
La interacción con el usuario es clave para que el sistema sea amigable e
intuitivo. En esta sección se describen cómo se presentarán los menús en
la consola, cómo se estructurarán los submenús y se ofrecen ejemplos
ilustrativos de las salidas y mensajes que se mostrarán durante el uso del
programa.
4.1. Diseño del Menú Principal
El Menú Principal es el primer punto de contacto entre el usuario y la
aplicación. Debe ser claro, sencillo y contener las opciones esenciales para
gestionar los préstamos. Algunos aspectos a tener en cuenta son:
Encabezado Informativo:
Mostrar un título o banner que identifique el sistema (por ejemplo,
"Sistema de Gestión de Préstamos").
Listado de Opciones:
Cada opción del menú debe estar numerada o identificada con una letra,
para que el usuario pueda seleccionar fácilmente la acción deseada. Por
ejemplo:
Agregar Préstamo
Modificar Préstamo
Eliminar Préstamo
Consultar Préstamos
Salir del Programa
Instrucciones Claras:
Indicar al usuario cómo debe introducir su elección (por ejemplo,
"Seleccione una opción escribiendo el número correspondiente").
Ejemplo de Menú Principal:
Este diseño guía al usuario y facilita la navegación a través de las
funcionalidades del sistema.
4.2. Submenús y Opciones del Sistema
En función de la opción seleccionada en el menú principal, se pueden
presentar submenús o pasos adicionales que permitan completar la acción
deseada. Por ejemplo:
Agregar Préstamo:
Al seleccionar esta opción, se mostrará un formulario paso a paso donde
se solicitarán los datos necesarios para registrar un préstamo.
Ejemplo de Submenú para Agregar Préstamo:
Cada campo deberá ser validado para asegurar que la información sea
correcta antes de guardarla en la base de datos.
Modificar Préstamo:
Se le pedirá al usuario que ingrese el identificador del préstamo que desea
modificar y, a continuación, se mostrará un menú con las opciones de
modificación (por ejemplo, cambiar el estado, actualizar el monto, etc.).
Eliminar Préstamo:
El sistema solicitará el identificador del préstamo a eliminar y, antes de
proceder, pedirá una confirmación para evitar eliminaciones accidentales.
Consultar Préstamos:
Se podrá mostrar un listado de todos los préstamos. Además, se podría
ofrecer la opción de filtrar o buscar por criterios (nombre del prestatario,
identificador, fecha, etc.).
Ejemplo de Submenú para Consultas:
Estos submenús permiten segmentar la información y las acciones,
facilitando al usuario el proceso de ingresar datos y tomar decisiones.
4.3. Ejemplos de Salidas y Mensajes en Consola
Es importante que la retroalimentación al usuario sea clara y precisa. A
continuación, se muestran algunos ejemplos de mensajes que el sistema
puede desplegar en distintas situaciones:
Confirmación de Acción Exitosa:
¡Préstamo agregado exitosamente!
Mensaje de Error al Ingresar Datos Incorrectos:
Error: El monto ingresado debe ser un valor numérico. Por
favor, intente nuevamente.
Confirmación de Eliminación:
¿Está seguro de que desea eliminar el préstamo con
identificador 123? (S/N):
Mensaje de Préstamo No Encontrado:
No se encontró ningún préstamo con el identificador ingresado.
Salida del Programa:
Gracias por utilizar el Sistema de Gestión de Préstamos. ¡Hasta
pronto!
Además, es recomendable utilizar separadores o líneas en la consola para
mejorar la legibilidad y estructurar visualmente la información:
-------------------------------------------------
Al integrar estos ejemplos, los estudiantes podrán visualizar cómo se debe
estructurar la interacción y adaptar los mensajes a las operaciones
realizadas, lo que contribuye a una experiencia de usuario más amigable
y profesional.
5. Persistencia de Datos con JSON
La persistencia de datos es fundamental para que la información generada
en el programa se mantenga disponible entre ejecuciones. En este
proyecto, se opta por utilizar el módulo json de Python para serializar
(convertir a formato JSON) y deserializar (cargar desde JSON) la
información almacenada en una lista de diccionarios.
5.1. Estructura de Datos: Lista de Diccionarios
El sistema de gestión de préstamos manejará la información mediante
una lista de diccionarios. Cada diccionario representa un registro
individual de préstamo y contendrá claves (keys) asociadas a los distintos
atributos del préstamo. Por ejemplo:
Identificador único: Un valor único que permita diferenciar cada
préstamo.
Nombre del prestatario: El nombre de la persona que solicita el préstamo.
Monto: El valor monetario del préstamo.
Fecha del préstamo: La fecha en la que se realizó el préstamo.
Estado: Indicador que puede reflejar si el préstamo está activo, finalizado,
vencido, etc.
Ejemplo de estructura de un registro:
Y la base de datos completa se mantendría en una lista:
Esta estructura permite una fácil manipulación y consulta de la
información.
5.2. Funciones de Guardado y Carga de Datos
Para mantener la persistencia de la información, se deben implementar
dos funciones clave que interactúan con el módulo json:
5.2.1. Función para Guardar Datos
Esta función se encargará de:
Serializar la lista de diccionarios: Convertir la estructura de datos en un
formato JSON.
Escribir en un archivo: Guardar la información en un archivo (por ejemplo,
prestamos.json) dentro de una carpeta designada (como data).
Puntos clave a considerar:
- Validar que la ruta del archivo exista o, de lo contrario, crearla.
- Manejar excepciones para detectar y resolver errores en la escritura
(por ejemplo, permisos insuficientes o disco lleno).
Ejemplo conceptual:
5.2.2. Función para Cargar Datos
Esta función se encarga de:
- Leer el archivo JSON: Abrir y leer el contenido del archivo que
contiene los datos.
- Deserializar la información: Convertir el JSON a la estructura de
datos original (lista de diccionarios).
- Manejar casos especiales: Como cuando el archivo no existe o está
corrupto, para lo cual se puede inicializar una lista vacía o informar
al usuario.
Ejemplo conceptual:
Implementar estas funciones permite que la aplicación:
• Inicie con los datos previamente guardados.
• Actualice el archivo cada vez que se modifiquen los registros de
préstamos.
5.3. Consideraciones y Buenas Prácticas
Para garantizar la integridad y consistencia de los datos, se recomienda
tener en cuenta las siguientes prácticas:
Validación de Datos:
Antes de guardar cualquier registro, se debe validar que la información
sea correcta y esté completa. Esto evitará la persistencia de datos
corruptos o incompletos.
Manejo de Errores:
Utilizar bloques try-except para capturar posibles errores durante la
lectura o escritura de archivos, informando al usuario y, en lo posible,
ofreciendo soluciones o acciones correctivas.
Uso de ensure_ascii=False e indent:
Al guardar los datos, es recomendable utilizar ensure_ascii=False para
conservar caracteres especiales (por ejemplo, acentos en español) y
indent=4 para que el archivo JSON sea legible y esté bien estructurado.
Actualización Atómica:
Para evitar la pérdida de datos en caso de fallos durante el guardado, se
puede implementar una estrategia de guardado atómico, donde primero
se escribe en un archivo temporal y, si todo es correcto, se reemplaza el
archivo original.
Respaldos Periódicos:
En entornos reales, se aconseja realizar copias de seguridad periódicas
del archivo JSON para prevenir pérdidas accidentales de datos.
Comentarios y Documentación:
Documentar las funciones de guardado y carga de datos ayuda a que
otros desarrolladores (o incluso los mismos estudiantes en el futuro)
comprendan rápidamente la finalidad y el funcionamiento de cada parte
del código.
6. Introducción a Git en el Proyecto
El uso de un sistema de control de versiones es fundamental para
cualquier proyecto de desarrollo, ya que permite llevar un registro
detallado de los cambios realizados, facilita la colaboración entre varios
desarrolladores y ayuda a mantener un historial del proyecto para poder
retroceder o analizar modificaciones. En este apartado se introducen los
conceptos básicos de Git, su importancia y se describen los comandos y
buenas prácticas esenciales para integrarlo en el proyecto de gestión de
préstamos.
6.1. Importancia del Control de Versiones
Historial de Cambios:
Git permite llevar un registro de todas las modificaciones realizadas en el
código. Cada cambio se guarda en un commit, lo que posibilita revisar
versiones anteriores o identificar cuándo y por qué se introdujo un
cambio.
Colaboración Efectiva:
En proyectos en equipo, Git facilita la integración del trabajo de diferentes
desarrolladores, gestionando y fusionando cambios de manera ordenada.
Seguridad y Respaldo:
Al mantener un repositorio remoto (por ejemplo, en GitHub, GitLab o
Bitbucket), se asegura que el código esté respaldado y se puede recuperar
en caso de fallos en el equipo local.
Organización del Desarrollo:
Permite la creación de ramas (branches) para desarrollar nuevas
funcionalidades o realizar pruebas sin afectar la versión principal del
proyecto, lo cual es esencial para un desarrollo estructurado y seguro.
6.2. Inicialización del Repositorio
El primer paso para integrar Git en el proyecto es inicializar un repositorio
en la carpeta raíz del mismo. Esto se logra mediante el siguiente comando
en la terminal: git init.
Este comando crea un subdirectorio oculto .git donde se almacenará todo
el historial de versiones y la configuración del repositorio.
Buenas prácticas al inicializar el repositorio:
.gitignore:
Crear un archivo .gitignore para excluir archivos o carpetas que no se
desean versionar (por ejemplo, archivos temporales, bases de datos
locales o configuraciones específicas del entorno).
Ejemplo de contenido para .gitignore:
Primer Commit:
Una vez agregados los archivos necesarios y configurado el .gitignore, se
debe realizar el primer commit que establezca el estado inicial del
proyecto.
git add . git commit -m "Commit inicial: Estructura base del
proyecto"
6.3. Comandos Básicos
Para un manejo básico de Git, es importante familiarizarse con los
siguientes comandos:
git add
Se utiliza para añadir cambios al área de preparación (staging area).
git add archivo.py
git add .
git commit:
Registra los cambios añadidos con un mensaje descriptivo.
git commit -m "Descripción de los cambios realizados"
git status
Muestra el estado actual del repositorio, indicando archivos modificados,
añadidos o pendientes de commit.
git log
Permite visualizar el historial de commits realizados.
git branch
Muestra las ramas existentes y permite gestionar nuevas ramas para
trabajar en funcionalidades separadas.
git branch
git branch nueva-funcionalidad
git checkout
Permite cambiar de rama o regresar a una versión anterior.
git checkout nueva-funcionalidad
git merge
Fusiona una rama con otra, integrando los cambios realizados en la rama
de trabajo a la rama principal (por ejemplo, master o main).
git checkout main
git merge nueva-funcionalidad
git push y git pull
Se utilizan para enviar y traer cambios a/desde un repositorio remoto.
git push origin main
git pull origin main
6.4. Flujo de Trabajo Sugerido y Buenas Prácticas
Para mantener un desarrollo organizado y minimizar conflictos, se
recomienda seguir un flujo de trabajo estructurado:
Crear una Rama para Cada Funcionalidad o Corrección:
Evita trabajar directamente en la rama principal. Por ejemplo:
git checkout -b agregar-modulo-gestion
Realizar Commits Frecuentes y Significativos:
Realiza commits pequeños y descriptivos, de manera que cada commit
represente un cambio lógico y fácilmente comprensible.
Actualizar la Rama Principal:
Antes de iniciar una nueva tarea, asegúrate de traer los últimos cambios
de la rama principal:
git checkout main
git pull origin main
Fusionar la Rama de Funcionalidad:
Una vez finalizada la tarea, fusiona la rama en la principal utilizando git
merge o creando un Pull Request si se usa una plataforma de repositorios
remotos.
Revisar y Resolver Conflictos:
Si surgen conflictos durante la fusión, revísalos cuidadosamente,
resuélvelos y realiza un commit para integrar los cambios.
Documentar el Progreso:
Usa mensajes de commit claros y, de ser necesario, incluye comentarios
en el código para facilitar el seguimiento de las modificaciones.
6.5. Resolución de Conflictos y Mantenimiento del Historial
Conflictos de Merge:
Cuando dos o más cambios se solapan en el mismo archivo, Git indicará
que existen conflictos que deben resolverse manualmente. Los pasos para
resolverlos son:
Identificar los archivos en conflicto utilizando git status.
Editar los archivos marcados, buscando las secciones delimitadas por:
Decidir qué código conservar, eliminar las marcas y guardar los cambios.
Añadir los archivos resueltos y realizar un commit.
Reescribir el Historial (Con Precaución):
Herramientas como git rebase permiten reescribir el historial para
mantener una línea de desarrollo más limpia. Se debe usar con
precaución, especialmente en repositorios compartidos, ya que puede
complicar la colaboración.
Etiquetas y Versionado:
Utilizar etiquetas (git tag) para marcar versiones importantes o hitos en
el desarrollo del proyecto. Esto facilita el seguimiento de lanzamientos o
versiones estables del sistema.
git tag -a v1.0 -m "Versión inicial del sistema de gestión de
préstamos"
git push origin v1.0
