Las ramas (branches) en Git son una de las características más poderosas y flexibles. Te permiten desarrollar nuevas funcionalidades, corregir errores o experimentar con el código sin afectar la rama principal del proyecto. Este enfoque facilita un desarrollo más seguro y colaborativo, ya que los cambios realizados en una rama no impactan inmediatamente en el resto del código hasta que se fusionan (merge).

¿Qué es una rama y por qué usarla?

Una rama (branch) es simplemente una referencia a una serie de commits. Cada vez que creas una rama nueva, Git comienza a seguir tus cambios de forma separada de otras ramas, permitiendo que trabajes en paralelo sin interferir con el código principal o con el trabajo de otros colaboradores.

¿Por qué usar ramas?

Desarrollo paralelo: Puedes trabajar en una nueva funcionalidad, corregir errores o probar nuevas ideas sin afectar la rama principal del proyecto (generalmente llamada main o master).
Colaboración segura: En proyectos con múltiples desarrolladores, cada uno puede trabajar en su propia rama y luego fusionar sus cambios cuando estén listos, minimizando el riesgo de conflictos.
Mejores prácticas de control de versiones: El uso de ramas para diferentes características y correcciones permite tener un historial de cambios más limpio y organizado.

Crear, listar y cambiar de ramas

Crear una rama

Para crear una nueva rama en Git, utilizas el comando git branch seguido del nombre que deseas darle a la rama.

Uso:

1git branch nombre-de-la-rama

Este comando crea una nueva rama, pero no te cambia automáticamente a esa rama.

Listar ramas

Puedes listar todas las ramas existentes en tu repositorio local con el siguiente comando:

Uso:
```
1git branch
```

El resultado te mostrará una lista de las ramas existentes, y la rama actual estará marcada con un asterisco (*).

Cambiar de rama

Para cambiar de una rama a otra, puedes usar el comando git checkout o el más reciente git switch.

Uso:

1git checkout nombre-de-la-rama

1git switch nombre-de-la-rama

Esto te moverá a la rama especificada. Si tienes cambios sin guardar, Git te pedirá que los confirmes (commit) o los guardes temporalmente (stash) antes de cambiar de rama.

`git checkout` vs `git switch`

En versiones más recientes de Git, el comando git switch se introdujo como una alternativa más clara y simple para cambiar entre ramas, ya que git checkout tenía múltiples usos que podían ser confusos.

git checkout: Se usa tanto para cambiar de ramas como para otras operaciones (como restaurar archivos a su versión anterior), lo que puede ser confuso.
- Cambiar de rama:
```
1git checkout nombre-de-la-rama
```
- Crear una nueva rama y cambiarte a ella:
```
1git checkout -b nueva-rama
```

git switch: Introducido para simplificar la operación de cambiar entre ramas.

Cambiar de rama:

1git switch nombre-de-la-rama

Crear una nueva rama y cambiarte a ella:

1git switch -c nueva-rama

En resumen, git switch está diseñado específicamente para cambiar de ramas, mientras que git checkout es más versátil y puede hacer más cosas.

`git merge`: Fusionar ramas

Cuando has terminado de trabajar en una rama y deseas integrar esos cambios en otra (por ejemplo, fusionar una rama de características con la rama principal), utilizas el comando git merge. Este comando combina el historial de commits de la rama en la que te encuentras con la rama que deseas fusionar.

Uso:

1git merge nombre-de-la-rama

Por ejemplo, si estás en la rama main y deseas fusionar los cambios de la rama desarrollo, ejecutarías:

1git checkout main
2git merge desarrollo

Esto combinará los commits de la rama desarrollo en main.

Estrategias de merge: fast-forward, no fast-forward, rebase

Cuando fusionas ramas en Git, hay diferentes estrategias de fusión que Git puede seguir, dependiendo de cómo han evolucionado las ramas entre sí.

1. Fast-forward merge

Una fusión fast-forward ocurre cuando la rama que estás fusionando no ha divergido de la rama actual. Esto significa que no se necesita crear un nuevo commit de fusión, simplemente Git "avanza" el puntero de la rama actual hasta el commit más reciente de la rama fusionada.

Uso: Es el comportamiento predeterminado cuando no ha habido cambios adicionales en la rama principal.

Ejemplo:

1git checkout main
2git merge desarrollo

Si desarrollo está por delante de main y no ha habido otros commits en main, Git moverá el puntero de main hacia adelante sin crear un nuevo commit de fusión.

2. No fast-forward merge

Una fusión no fast-forward crea un commit de fusión incluso si la rama puede ser avanzada sin problemas. Esto es útil para mantener un historial claro de que una fusión ha ocurrido.

Uso:

1git merge --no-ff nombre-de-la-rama

Ventajas:
- Mantiene un historial de commits más explícito, mostrando cuándo una rama fue fusionada.

3. Rebase

En lugar de fusionar dos ramas, el comando git rebase reescribe el historial de commits de una rama para aplicarlo "sobre" otra. Esto crea un historial más lineal, eliminando los commits de fusión.

Uso:

1git rebase nombre-de-la-rama

El rebase es útil para mantener un historial limpio, pero es más peligroso porque reescribe la historia de los commits. Es mejor usarlo solo si estás trabajando solo o en una rama que no ha sido compartida con otros.

Resolución de conflictos en merges

A veces, cuando intentas fusionar dos ramas, Git encuentra cambios en los mismos archivos que no puede combinar automáticamente. Esto se conoce como un conflicto de fusión (merge conflict). Cuando esto ocurre, Git marca los archivos con conflictos y te pide que los resuelvas manualmente.

Cómo identificar y resolver conflictos:

Durante una fusión: Si Git encuentra un conflicto, te mostrará un mensaje como:
```
Auto-merging archivo.txt
CONFLICT (content): Merge conflict in archivo.txt
```
Esto significa que tienes un conflicto en archivo.txt.
Ver archivos en conflicto: Puedes usar el comando git status para ver qué archivos están en conflicto.
```
1git status
```
Verás algo como:
```
both modified: archivo.txt
```
Abrir el archivo en conflicto: Abre el archivo en tu editor de texto y verás algo como esto:
```
<<<<<<< HEAD
Código en la rama actual
=======
Código en la rama que estás fusionando
>>>>>> nombre-de-la-rama
```
Aquí, debes elegir qué parte del código conservar, o combinar las dos versiones manualmente. Después de resolver el conflicto, guarda el archivo.
Marcar el conflicto como resuelto: Una vez resuelto el conflicto, debes añadir el archivo al Staging Area usando git add:
```
1git add archivo.txt
```
Completar la fusión: Finalmente, completa la fusión confirmando los cambios:
```
1git commit
```
Git creará un commit de fusión que incluye los cambios que has resuelto.

Resumen

El uso de ramas en Git te permite desarrollar nuevas funcionalidades, corregir errores y colaborar en equipo de manera eficiente y segura. Crear, cambiar y fusionar ramas es esencial en el flujo de trabajo de Git, y el uso de diferentes estrategias de fusión como fast-forward, no fast-forward y rebase te da flexibilidad para gestionar el historial de tu proyecto. Finalmente, la resolución de conflictos es un proceso clave que debes dominar para manejar fusiones complejas.

Curso git nivel medio