Lección 10 de 12 · Lectura y práctica
Crear, cambiar y eliminar ramas
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.
Del concepto a la práctica
Taller de esta lección
Crear y eliminar ramas es seguro cuando primero verificas dónde estás y si la historia ya fue integrada. Un nombre descriptivo comunica intención; una eliminación forzada, en cambio, puede ocultar trabajo no incorporado y debe evitarse durante la práctica normal.
Ejemplo resuelto
Desde main se crea fix/telefono-sala, se cambia a ella y se corrige un número. Tras integrar el commit en main, git branch --merged muestra la rama como integrada y permite eliminarla localmente con git branch -d.
Pruébalo
Comprueba la rama actual con
git branch --show-current.Crea y cambia a
fix/telefono-salacongit switch -c.Confirma la corrección y vuelve a
main.Integra la rama, consulta las ramas integradas y elimínala sin forzar.
Error frecuente: intentar borrar la rama desde ella misma o antes de integrarla. Corrígelo cambiando a main y usando git branch --merged; si no aparece, conserva la rama y revisa su historial.
Comprueba tu resultado
Ejercicio: muestra git branch --list y git log --oneline --all después de la limpieza. El resultado esperado es que main conserve el commit de corrección y que la rama local de trabajo ya no aparezca.

Mapa de prácticaLos cambios se preparan en una rama y se registran en commits pequeños. Las pruebas y la revisión del pull request comprueban el cambio antes de integrarlo. El historial permite entender qué se modificó y recuperar una versión anterior.
Ver la infografía en tamaño completo ↗Fuentes para profundizar
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:
| Prefijo | Uso | Ejemplo |
|---|---|---|
| feature/ | Nueva funcionalidad | feature/login-usuarios |
| bugfix/ | Corrección de errores | bugfix/corregir-login |
| hotfix/ | Arreglos urgentes en producción | hotfix/seguridad-criticala |
| release/ | Preparación de versiones | release/v2.0.0 |
feature/nuevo-dashboard en lugar de feature/nuevoDashboard. Esto mejora la legibilidad y es la convención más aceptada en la comunidad.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 comandogit switch -ces más intuitivo quecheckoutporquecheckouttiene demasiadas responsabilidades (cambiar ramas, restaurar archivos, etc.). Git creóswitchespecí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.
git stash antes de cambiar de 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
Ver más: Diferencias entre checkout y switch
| Comando | Función | Uso principal |
|---|---|---|
| git checkout | Cambiar ramas Y restaurar archivos | Descontinuado para ramas |
| git switch | Solo cambiar ramas | Recomendado actualmente |
| git restore | Solo restaurar archivos | Recomendado actualmente |
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.
Ctrl + - puede funcionar como historial para navegar entre ubicaciones, pero git switch - es específico para ramas Git.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.
error: The branch 'feature/prueba' is not fully merged. Esto es una característica de seguridad, no un bug.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.
-D es irreversible. Si la rama tenía commits únicos, los perderás (excepto que estén referenciados por otra rama o tags). Asegúrate de tener todo el código necesario antes de usar esta opción.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:
- Iniciar el proyecto: Creas un repositorio y trabajas en
main - Crear rama para nueva funcionalidad:
git switch -c feature/registro-usuarios - Desarrollar y hacer commits: Añades el código del registro
- Cambiar a main para revisión:
git switch main - Volver a la rama para más cambios:
git switch feature/registro-usuarios - Fusionar los cambios:
git merge feature/registro-usuarios - 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
| Error | Causa | Solución |
|---|---|---|
| fatal: not a valid branch name | Nombre con caracteres inválidos | Usa solo letras, números, guiones y barras |
| error: cannot switch branch | Cambios sin guardar entran en conflicto | Haz commit, usa stash, o descarta cambios |
| error: branch not found | Rama no existe o error de escritura | Verifica con git branch y comprueba el nombre |
| warning: deleting branch that has not been merged | Intentar -d en rama sin fusionar |
Usa -D si es intencional, o fusiona primero |
Resumen
En esta lección aprendiste las operaciones fundamentales con ramas:
- Crear:
git branch nombreogit switch -c nombre - Cambiar:
git switch nombre(recomendado) ogit checkout nombre - Eliminar:
git branch -d nombre(seguro) ogit 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.
¿Cuál de los siguientes comandos crea una rama Y cambia a ella inmediatamente?
- A) git branch feature/nueva
- B) git checkout -b feature/nueva
- C) git branch -d feature/nueva
- D) git push origin feature/nueva
git checkout -b feature/nueva. El indicador -b crea la rama y cambia a ella en un solo paso. La opción A solo crea la rama sin cambiar, C elimina una rama, y D crea una rama remota.¿Qué sucede si intentas eliminar una rama con git branch -d que aún no ha sido fusionada?
- A) Se elimina sin preguntar
- B) Git muestra un error y no la elimina
- C) Git pide confirmación
- D) Solo elimina los commits
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!
Sigue con Git y GitHub para Equipos
Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.
Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.