Saltar al contenido

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

  1. Comprueba la rama actual con git branch --show-current.

  2. Crea y cambia a fix/telefono-sala con git switch -c.

  3. Confirma la corrección y vuelve a main.

  4. 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.

Rama de trabajo con commits, pruebas y revisión antes de integrarla en la rama principal.
CursaloMapa de práctica
Cambios pequeños, revisión clara

Los 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.

CONCEPTO CLAVE: Una rama en Git es simplemente un puntero móvil a un commit específico. Crear una rama es crear un nuevo puntero; no significa copiar todo el código. Por eso Git puede crear ramas de forma instantánea y eficiente.

¿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
💡 Consejo: Usa guiones (-) para separar palabras: 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 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
📌 Buena práctica: Mantén tus nombres de ramas en minúsculas y usa solo letras, números y guiones. Evita espacios, caracteres especiales y acentos para prevenir problemas de compatibilidad entre sistemas operativos.

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.

⚠️ Advertencia: Si tienes cambios sin guardar (archivos modificados pero no commitados) y intentas cambiar de rama, Git puede impedirte si los cambios entran en conflicto. Siempre haz commit o usa 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.

💡 Atajo de teclado: En la terminal, presionar 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.

⚠️ Advertencia: Si intentas eliminar una rama que NO ha sido fusionada, Git te mostrará un error como: 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.

📌 Importante: Usar -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:

  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

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 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.
🧠 Quiz

¿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
✅ Respuesta correcta: B) 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.
🧠 Quiz

¿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
✅ Respuesta correcta: B) Git muestra un error y no elimina la rama. Esta es una característica de seguridad para prevenir pérdida de trabajo no fusionado.

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.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.