GIT Guía Completa en Español – Trabajando con Ramas (Branches)

git branch – Crear y listar ramas

El comando git branch es tu herramienta principal para gestionar las ramas en tu repositorio. Te permite crear nuevas ramas, listar las ramas existentes, renombrarlas y eliminarlas. Es fundamental para organizar tu trabajo, experimentar con nuevas funcionalidades, corregir errores y colaborar con otros desarrolladores.

¿Qué hace git branch?

• Sin argumentos: Lista todas las ramas existentes en tu repositorio local, indicando cuál es la rama actual con un asterisco (*).
• Con un argumento (nombre de rama): Crea una nueva rama con el nombre especificado a partir del commit actual.
• Con la opción -d o --delete: Elimina la rama especificada (solo si ya ha sido fusionada).
• Con la opción -m o --move: Renombra la rama especificada.

¿Cuándo usar git branch?

• Crear una nueva rama: Cuando quieres empezar a trabajar en una nueva funcionalidad, corrección de errores o experimento sin afectar la rama principal.
• Listar ramas: Para ver todas las ramas existentes en tu repositorio y saber en cuál estás trabajando actualmente.
• Eliminar ramas: Para limpiar tu repositorio y eliminar ramas que ya no son necesarias.
• Renombrar ramas: Para cambiar el nombre de una rama si es necesario.

Cómo usar git branch:

1. Listar ramas:
   • git branch
2. Crear una nueva rama:
   • git branch <nombre-rama>
3. Eliminar una rama:
   • git branch -d <nombre-rama>
4. Renombrar una rama:
   • git branch -m <nombre-rama-antiguo> <nombre-rama-nuevo>

Ejemplos:

# Listar todas las ramas
git branch

# Crear una nueva rama llamada 'nueva-funcionalidad'
git branch nueva-funcionalidad

# Eliminar la rama 'rama-obsoleta' (si ya ha sido fusionada)
git branch -d rama-obsoleta

# Renombrar la rama 'rama-antigua' a 'rama-nueva'
git branch -m rama-antigua rama-nueva

Consideraciones:

• Rama actual: La rama en la que estás trabajando actualmente se indica con un asterisco (*) al listar las ramas.
• Cambios no guardados: Asegúrate de haber hecho commit de todos los cambios en tu rama actual antes de crear o cambiar a otra rama, para evitar perder trabajo.
• Ramas remotas: El comando git branch solo muestra las ramas locales. Para ver las ramas remotas, utiliza git branch -r o git branch -a (para ver tanto las ramas locales como las remotas).

git checkout – Cambiar de rama

El comando git checkout es tu billete de viaje entre las diferentes ramas de tu repositorio. Te permite moverte de una rama a otra, actualizando el contenido de tu Working Tree (directorio de trabajo) para reflejar los archivos y cambios específicos de la rama seleccionada. Es como cambiar de escenario en una obra de teatro, donde cada rama representa una escena diferente de tu proyecto.

¿Qué hace git checkout?

• Cambia el puntero HEAD a la rama especificada.
• Actualiza el Working Tree para que coincida con el contenido de la rama seleccionada.
• Prepara el Staging Area para que los próximos cambios se realicen en la nueva rama.

¿Cuándo usar git checkout?

• Cambiar de contexto: Cuando necesitas trabajar en una rama diferente, ya sea para desarrollar una nueva funcionalidad, corregir un error o revisar el trabajo de otro desarrollador.
• Crear y cambiar a una nueva rama: Puedes usar git checkout -b <nombre-rama> para crear una nueva rama y cambiar a ella automáticamente en un solo paso.
• Revisar versiones anteriores: Puedes usar git checkout <identificador-commit> para “viajar en el tiempo” y ver cómo era tu proyecto en un commit específico, aunque no podrás hacer cambios en ese estado a menos que crees una nueva rama a partir de él.

Cómo usar git checkout:

• Cambiar a una rama existente: git checkout <nombre-rama>
• Crear y cambiar a una nueva rama: git checkout -b <nombre-rama>
• Revisar un commit específico (modo de solo lectura): git checkout <identificador-commit>

Ejemplos:

Consideraciones:

• Cambios no guardados: Antes de cambiar de rama, asegúrate de haber hecho commit o guardado tus cambios en la rama actual para evitar perder trabajo. GIT te advertirá si intentas cambiar de rama con cambios no guardados.
• Conflictos: Si tienes cambios no guardados en tu Working Tree que entran en conflicto con los archivos de la rama a la que quieres cambiar, GIT te impedirá cambiar de rama hasta que resuelvas los conflictos o descartes tus cambios.
• HEAD detached: Cuando haces checkout a un commit específico, entras en un estado llamado “HEAD detached”, donde no estás en ninguna rama. Cualquier cambio que hagas en este estado no se guardará a menos que crees una nueva rama a partir de ese commit.

git merge – Fusionar ramas

El comando git merge es la herramienta que te permite integrar los cambios de una rama en otra, combinando sus historiales de commits. Es como unir dos caminos que se habían separado, creando un nuevo camino que incorpora los avances de ambos.

¿Qué hace git merge?

• Combina los cambios de la rama especificada (la rama que quieres fusionar) en la rama actual (la rama en la que estás trabajando).
• Crea un nuevo commit de merge que une los historiales de ambas ramas.
• Resuelve automáticamente los conflictos si es posible, o te pide que los resuelvas manualmente si es necesario.

¿Cuándo usar git merge?

• Integración de funcionalidades: Cuando has terminado de desarrollar una nueva funcionalidad en una rama separada y quieres incorporarla a la rama principal.
• Corrección de errores: Cuando has corregido un error en una rama separada y quieres aplicar esa corrección a la rama principal.
• Colaboración: Cuando varios desarrolladores han estado trabajando en diferentes ramas y quieren combinar sus cambios en una sola rama.

Cómo usar git merge:

• Cambiar a la rama destino: Utiliza git checkout <nombre-rama-destino> para moverte a la rama donde quieres integrar los cambios.
• Ejecutar el merge: Escribe git merge <nombre-rama-origen> y presiona Enter. Reemplaza <nombre-rama-origen> con el nombre de la rama que contiene los cambios que quieres integrar.

Ejemplo:

Tipos de Merges:

• Fast-forward merge: Ocurre cuando la rama que quieres fusionar está directamente por delante de la rama actual. GIT simplemente mueve el puntero de la rama actual hacia adelante para incluir los nuevos commits. Es el tipo de merge más simple y no crea un nuevo commit de merge.
• 3-way merge: Ocurre cuando las dos ramas que quieres fusionar han divergido, es decir, tienen commits diferentes. GIT crea un nuevo commit de merge que combina los cambios de ambas ramas. Este tipo de merge puede generar conflictos si ambas ramas han modificado las mismas líneas de código.

Conflictos de Merge:

• Surgen cuando GIT no puede fusionar automáticamente los cambios de ambas ramas porque han modificado las mismas líneas de código de manera diferente.
• GIT te mostrará los archivos en conflicto y te pedirá que los resuelvas manualmente.
• Para resolver un conflicto, debes editar el archivo en conflicto, elegir qué cambios mantener y eliminar las marcas de conflicto que GIT ha añadido.
• Una vez resueltos los conflictos, añade los archivos al Staging Area con git add y haz un commit para completar el merge.

Resolución de conflictos (Merge Conflicts)

Los conflictos de fusión (merge conflicts) son situaciones en las que GIT no puede fusionar automáticamente los cambios de dos ramas porque han modificado las mismas líneas de código de manera diferente. Esto puede ocurrir cuando dos desarrolladores trabajan en la misma parte del código al mismo tiempo o cuando una rama ha sido modificada significativamente después de que otra rama se ramificó de ella.

¿Cómo identificar un conflicto de merge?

• Cuando intentas hacer un git merge, GIT te mostrará un mensaje de error indicando que hay conflictos.
• El comando git status también te mostrará los archivos que tienen conflictos.
• Los archivos en conflicto tendrán marcas especiales dentro de ellos, como:
  • <<<<<<< HEAD: Indica el inicio de los cambios de tu rama actual.
  • =======: Separa los cambios de tu rama actual de los cambios de la otra rama.
  • >>>>>>> <nombre-rama>: Indica el final de los cambios de la otra rama.

¿Cómo resolver un conflicto de merge?

• Abre el archivo en conflicto en un editor de texto.
• Identifica las secciones en conflicto: Busca las marcas <<<<<<<, ======= y >>>>>>>.
• Decide qué cambios mantener: Revisa los cambios de ambas ramas y decide qué versión del código quieres conservar.
• Edita el archivo: Elimina las marcas de conflicto y modifica el código para que quede como deseas.
• Guarda el archivo: Guarda los cambios en el archivo.
• Añade el archivo al Staging Area: Utiliza git add <archivo> para marcar el conflicto como resuelto.
• Haz un commit: Utiliza git commit para crear un nuevo commit que incluya la resolución del conflicto.

Ejemplo de un conflicto de merge:

Posibles soluciones:

• Mantener los cambios de tu rama actual:def saludar(nombre): print(f”¡Hola, {nombre}!”)
• Mantener los cambios de la otra rama:def saludar(nombre): print(f”¡Buenos días, {nombre}!”)
• Combinar los cambios:def saludar(nombre): print(f”¡Hola, {nombre}! ¡Buenos días!”)

Herramientas para resolver conflictos:

• Editores de texto: La mayoría de los editores de texto modernos tienen funciones para resaltar y navegar entre las secciones en conflicto, lo que facilita su resolución.
• Herramientas de merge visuales: Existen herramientas gráficas que te permiten visualizar los cambios de ambas ramas y seleccionar qué cambios mantener de forma más intuitiva.

Lee la guía completa acá.