Crear, Cambiar y Eliminar Ramas en Git

En el módulo anterior exploramos qué son las ramas y por qué son fundamentales para el trabajo en equipo. Ahora aprenderás a crear ramas, cambiar entre ellas y eliminarlas cuando ya no sean necesarias. Estas son las operaciones más básicas que realizarás a diario en cualquier proyecto con Git.

¿Qué aprenderás en esta lección?

• Crear ramas locales y remotas
• Cambiar entre ramas usando diferentes comandos
• Eliminar ramas de forma segura
• Evitar errores comunes al trabajar con ramas

1. Crear Ramas

1.1 Crear una rama local

Para crear una nueva rama en tu repositorio local, utilizas el comando git branch seguido del nombre que deseas asignar:

git branch nombre-de-la-rama

Es importante elegir nombres descriptivos. Las ramas típicamente siguen estos patrones:

1.2 Crear y cambiar en un solo paso

El comando git branch solo crea la rama, pero no te mueve a ella. Si deseas crear y cambiar inmediatamente, tienes dos opciones:

# Opción 1: git checkout -b (clásico)
git checkout -b feature/nueva-funcionalidad

# Opción 2: git switch -c (moderno, Git 2.23+)
git switch -c feature/nueva-funcionalidad

El comando git switch -c es más intuitivo que checkout porque checkout tiene demasiadas responsabilidades (cambiar ramas, restaurar archivos, etc.). Git creó switch específicamente para cambiar ramas.

1.3 Ver todas las ramas

Para ver qué ramas existen en tu repositorio:

# Ver ramas locales
git branch

# Ver ramas locales con más detalle
git branch -v

# Ver todas las ramas (locales y remotas)
git branch -a

El asterisco (*) indica la rama en la que estás actualmente:

$ git branch
* main
  feature/login
  bugfix/corregir-error
  desarrollo

2. Cambiar Entre Ramas

2.1 Usando git checkout

El comando tradicional para cambiar de rama es:

git checkout nombre-de-la-rama

Por ejemplo, para cambiar a la rama feature/dashboard:

git checkout feature/dashboard

Git cambiará tu directorio de trabajo al estado del último commit de esa rama.

2.2 Usando git switch (recomendado)

Desde Git 2.23, se recomienda usar git switch para cambiar ramas:

# Cambiar a una rama existente
git switch feature/dashboard

# Cambiar de vuelta a la rama principal
git switch main

2.3 Cambiar a la rama anterior

Si necesitas volver rápidamente a la rama donde estabas antes:

git switch -

Este atajo es equivalente a git checkout - y alterna entre las dos últimas ramas.

3. Eliminar Ramas

3.1 Eliminar una rama local

Cuando termines de trabajar en una rama y hayas fusionado (merge) tus cambios, puedes eliminarla:

git branch -d nombre-de-la-rama

El indicador -d (de delete) solo elimina la rama si ya fue fusionada. Es una protección para evitar perder trabajo.

3.2 Forzar eliminación

Si realmente necesitas eliminar una rama sin fusionar (por ejemplo, fue un experimento que no funcionó):

git branch -D nombre-de-la-rama

Con -D (mayúscula) forzamos la eliminación sin importar si está fusionada o no.

3.3 Eliminar una rama remota

Las ramas remotas también se pueden eliminar. Esto elimina la referencia en el repositorio remoto, no el código en sí:

# Eliminar la rama remota
git push origin --delete nombre-de-la-rama

# Verificar que se eliminó
git branch -a

3.4 Limpiar ramas que ya no existen en remoto

Después de que alguien elimina una rama en el remoto, tu repositorio local aún tendrá la referencia. Para sincronizar:

# Eliminar referencias a ramas remotas eliminadas
git fetch --prune

# O configurar Git para hacerlo automáticamente
git config --global fetch.prune true

4. Ejemplo Práctico Completo

Veamos un flujo de trabajo típico:

1. Iniciar el proyecto: Creas un repositorio y trabajas en main
2. Crear rama para nueva funcionalidad: git switch -c feature/registro-usuarios
3. Desarrollar y hacer commits: Añades el código del registro
4. Cambiar a main para revisión: git switch main
5. Volver a la rama para más cambios: git switch feature/registro-usuarios
6. Fusionar los cambios: git merge feature/registro-usuarios
7. Eliminar la rama: git branch -d feature/registro-usuarios

# Flujo completo
$ git status
On branch main
$ git switch -c feature/registro
Switched to a new branch 'feature/registro'
$ echo "código del registro" > registro.py
$ git add registro.py
$ git commit -m "Añadir funcionalidad de registro"
[feature/registro abc123] Añadir funcionalidad de registro
 1 file changed, 1 insertion(+)
$ git switch main
Switched to branch 'main'
$ git merge feature/registro
Updating abc123..def456
 Fast-forward
 registro.py | 1 +
 1 file changed, 1 insertion(+)
$ git branch -d feature/registro
Deleted branch feature/registro (was def456).

5. Errores Comunes y Soluciones

Resumen

En esta lección aprendiste las operaciones fundamentales con ramas:

• Crear: git branch nombre o git switch -c nombre
• Cambiar: git switch nombre (recomendado) o git checkout nombre
• Eliminar: git branch -d nombre (seguro) o git branch -D nombre (forzado)
• Eliminar remota: git push origin --delete nombre

Dominar estas operaciones básicas te permitirá navegar fluidamente entre diferentes líneas de desarrollo, organizar tu trabajo y colaborar eficazmente con tu equipo.

Próximos Pasos

Ahora que dominas crear, cambiar y eliminar ramas, estás listo para aprender a fusionar ramas (merge) y entender cómo resolver conflictos cuando dos ramas modifican las mismas líneas de código. ¡Continúa con la siguiente lección!