Ramas y Fusiones

@yoezequiel 19-03-2025

Módulo 3: Ramas y Fusiones en Git

Objetivo: Aprender a gestionar ramas en Git.
Contenido:
- Crear una rama:
```
git branch nombre-de-la-rama
```
- Listar ramas:
```
git branch
```
  - La rama actual se marca con un asterisco (*).
- Eliminar una rama:
```
git branch -d nombre-de-la-rama
```
  - Usar -D en lugar de -d para forzar la eliminación si la rama no está fusionada.

Objetivo: Aprender a moverse entre ramas.
Contenido:
- Cambiar a una rama existente:
```
git checkout nombre-de-la-rama
```
- Crear y cambiar a una nueva rama:
```
git checkout -b nombre-de-la-rama
```
- Nota: git checkout también se usa para restaurar archivos, lo que puede causar confusión.

Objetivo: Usar una alternativa más intuitiva para cambiar entre ramas.
Contenido:
- Cambiar a una rama existente:
```
git switch nombre-de-la-rama
```
- Crear y cambiar a una nueva rama:
```
git switch -c nombre-de-la-rama
```
- Ventaja: git switch es más específico y evita confusiones con la restauración de archivos.

Objetivo: Aprender a combinar cambios de una rama en otra.
Contenido:
- Pasos para fusionar:
  - Cambia a la rama que recibirá los cambios (por ejemplo, main):
```
git switch main
```
  - Fusiona la rama deseada (por ejemplo, feature-branch):
```
git merge feature-branch
```
- Resultado: Los cambios de feature-branch se integran en main.
- Nota: Si no hay conflictos, Git crea un “merge commit” automáticamente.

Objetivo: Aprender a manejar conflictos al fusionar ramas.
Contenido:
- ¿Qué es un conflicto?: Ocurre cuando Git no puede fusionar cambios automáticamente (por ejemplo, cambios en la misma línea de un archivo).
- Pasos para resolver conflictos:
  - Git marca los archivos con conflictos. Usa git status para identificarlos.
  - Abre los archivos conflictivos y busca las marcas de conflicto:
```
<<<<<<< HEAD
Cambios en la rama actual (main).
=======
Cambios en la rama fusionada (feature-branch).
>>>>>>> feature-branch
```
  - Edita el archivo para resolver el conflicto, eliminando las marcas y dejando el código deseado.
  - Añade los archivos resueltos al Staging Area:
```
git add nombre-del-archivo
```
  - Completa el merge con:
```
git commit
```

Objetivo: Aprender a reorganizar el historial de commits para mantener un flujo lineal.
Contenido:
- ¿Qué es rebase?: Es una alternativa a git merge que reaplica los commits de una rama sobre otra.
- Uso básico:
  - Cambia a la rama que deseas reaplicar (por ejemplo, feature-branch):
```
git switch feature-branch
```
  - Ejecuta rebase sobre la rama base (por ejemplo, main):
```
git rebase main
```
- Resultado: Los commits de feature-branch se reaplican sobre main, creando un historial lineal.

Objetivo: Entender cuándo usar merge y cuándo usar rebase.
Contenido:
- Merge:
  - Combina ramas creando un nuevo “merge commit”.
  - Mantiene el historial completo, incluyendo ramificaciones.
  - Ideal para integrar ramas en proyectos colaborativos.
- Rebase:
  - Reaplica commits sobre otra rama, creando un historial lineal.
  - Útil para mantener un historial limpio y fácil de seguir.
  - No recomendado para ramas compartidas (puede causar conflictos).

Las ramas permiten trabajar en características o correcciones de forma aislada.
git branch gestiona ramas, git checkout y git switch permiten cambiar entre ellas.
git merge combina ramas, pero puede generar conflictos que deben resolverse manualmente.
git rebase reorganiza el historial de commits, creando un flujo lineal.
merge es mejor para integrar ramas en proyectos colaborativos, mientras que rebase es ideal para mantener un historial limpio.