git branch

Qué hace git branch

El comando git branch crea, lista, renombra y elimina ramas. Esa es su función completa — no cambia tu árbol de trabajo a una rama y no fusiona trabajo. Esas tareas corresponden a git checkout / git switch y git merge. Piensa en git branch como la herramienta que gestiona las etiquetas, mientras que los otros comandos te mueven entre ellas y las vuelven a unir.

Esta página explica qué es una rama en realidad, cómo crearlas y listarlas, cómo renombrarlas y eliminarlas (localmente y en un remoto), y los errores comunes que suelen ocurrir.

Qué es realmente una rama

Una rama en Git no es una copia de tus archivos — es un puntero ligero y móvil a un único commit. Cada commit también apunta a su(s) padre(s), por lo que seguir un puntero de rama hacia atrás a través de sus padres reconstruye el historial completo de esa línea de trabajo.

Dado que una rama es simplemente un archivo de 41 bytes que contiene un hash de commit, crearla es instantáneo y cuesta casi nada:

cat .git/refs/heads/main
# 9f1c2a7e8d... (the commit your branch currently points at)

Un puntero especial llamado HEAD registra en qué rama te encuentras actualmente. Cuando haces un commit, el puntero de la rama actual avanza al nuevo commit y HEAD lo sigue. Por eso las ramas son tan económicas en Git en comparación con los sistemas de control de versiones más antiguos que duplicaban físicamente los archivos.

Por qué usar ramas

Las ramas te dan una línea de desarrollo aislada. Puedes construir una funcionalidad o corregir un error en su propia rama sin tocar la rama estable main, y luego fusionarla cuando esté lista. Razones comunes:

• Desarrollar dos funcionalidades en paralelo sin que sus cambios entren en conflicto.
• Mantener main siempre listo para publicar mientras el código experimental vive en otro lugar.
• Limpiar el historial antes de fusionar, para que la rama compartida se mantenga ordenada.
• Abrir un pull request — la mayoría de plataformas construyen los PR alrededor de ramas.

Opciones comunes

Crear ramas

Las ramas son solo punteros a commits. Cuando creas una, Git añade un nuevo puntero en tu commit actual — no cambia el historial.

Crea una rama en tu commit actual:

git branch test_branch

Se crea un nuevo puntero al commit actual; nada más se mueve:

Crear una rama no te cambia a ella — HEAD sigue apuntando a la rama anterior. Para empezar a trabajar en la nueva rama, cámbiala y luego usa git add y git commit para registrar el trabajo:

git switch test_branch     # modern; or: git checkout test_branch

La mayoría de las veces querrás crear y cambiar en un solo paso:

git switch -c test_branch     # create + switch (modern)
git checkout -b test_branch   # create + switch (older syntax, identical effect)

También puedes crear una rama desde un punto específico en lugar de HEAD — una etiqueta, otra rama o un hash de commit:

git branch hotfix v1.0        # branch starting at the v1.0 tag
git branch experiment 9f1c2a7 # branch starting at an old commit

Listar e inspeccionar ramas

Ejecutar git branch sin argumentos muestra tus ramas locales y marca la actual:

git branch
#   feature-login
# * main
#   test_branch

Añade -v para ver a dónde apunta cada rama:

git branch -v
#   feature-login 1a2b3c4 Add login form
# * main          9f1c2a7 Update README
#   test_branch   9f1c2a7 Update README

Para saber qué ramas son seguras de limpiar, lista las que ya están fusionadas en tu rama actual. Todo lo que aparezca aquí puede eliminarse con -d:

git branch --merged
#   feature-login
# * main

Renombrar ramas

Usa -m (mover) para renombrar. Para renombrar la rama en la que estás actualmente, indica solo el nuevo nombre:

git branch -m better-name

Para renombrar una rama diferente, indica tanto el nombre antiguo como el nuevo:

git branch -m old-name new-name

Si ya existe una rama con el nombre de destino, -m se niega a sobrescribirla; usa -M para forzar el renombrado. Ten en cuenta que renombrar una rama que existe en un remoto no la renombra allí — debes subir el nuevo nombre y eliminar el antiguo.

Eliminar ramas

Después de que una rama se fusiona en main, elimina el puntero local para mantener tu lista de ramas ordenada:

git branch -d test_branch
# Deleted branch test_branch (was 9f1c2a7).

La opción -d es una comprobación de seguridad: se niega a eliminar una rama cuyos commits no están aún fusionados en la rama actual, para que no pierdas trabajo:

git branch -d test_branch
# error: The branch 'test_branch' is not fully merged.
# If you are sure you want to delete it, run 'git branch -D test_branch'.

Si estás seguro de que quieres eliminar la rama (y sus commits sin fusionar), usa la -D en mayúscula para forzarlo:

git branch -D test_branch

Eliminar una rama remota

Los comandos anteriores solo eliminan tu copia local. La rama puede seguir existiendo en el remoto (por ejemplo en origin). Para eliminarla allí:

git push origin --delete test_branch

La sintaxis de dos puntos más antigua hace lo mismo — envía "nada" a la rama remota, lo que la elimina:

git push origin :test_branch

Para crear una rama en un remoto, sube una rama local; el primer push la establece en el remoto y (con -u) configura el seguimiento. Consulta git push y git remote para más detalles:

git push -u origin test_branch
# pushes test_branch to origin and tracks it

Un ejemplo completo

Este es el ciclo típico de crear → trabajar → fusionar → limpiar de principio a fin:

git switch -c feature-x        # create and switch to the branch
# ... edit files ...
git add .
git commit -m "Add feature X"

git switch main                # back to main
git merge feature-x            # bring the work in
git branch -d feature-x        # delete the now-merged local branch
git push origin --delete feature-x   # and remove it from the remote

Práctica