Ramas de la lista Git: Una guía práctica

Si alguna vez has trabajado en más de una función al mismo tiempo, esta situación te resultará familiar: ejecutas un comando Git y ahora ya no estás seguro de dónde se encuentra realmente tu trabajo de la semana pasada.

Este problema se vuelve más común a medida que los proyectos crecen. Al principio, un repositorio solo puede tener una rama main. Sin embargo, con el tiempo, los equipos crean ramas para nuevas funciones, correcciones de errores, experimentos, lanzamientos y revisiones de emergencia. 

Aquí es donde resulta esencial enumerar las ramas en Git. Ayuda a responder preguntas prácticas:

• ¿En qué rama estoy trabajando actualmente?
• ¿Qué otras ramas existen en tu máquina?
• ¿Qué ramas existen en el repositorio remoto?

En esta guía, veremos los conceptos básicos para listar ramas en Git, cómo hacerlo y cómo solucionar problemas comunes.

Si Git es completamente nuevo para ti, te recomiendo que realices nuestro curso Introducción a Git para que adquieras confianza antes de profundizar en temas más detallados sobre la gestión de ramas.

Comprender las ramas de Git

Antes de empezar a enumerarlas, veamos qué son las ramas de Git. 

Un error común es pensar que las ramas de Git son carpetas independientes o copias completas de un código base, pero en realidad, una rama de Git es solo un puntero ligero a una confirmación específica.

Puedes considerarlo como una línea temporal paralela en la que puedes crear funciones o experimentar de forma aislada sin afectar al código principal estable. Esta arquitectura hace que crear y fusionar ramas sea increíblemente rápido y eficiente.

Fuente: Git

Git realiza un seguimiento de tu posición actual en estas líneas de tiempo utilizando una referencia especial llamada HEAD, que siempre apunta a la rama en la que estás trabajando actualmente. Dado que las ramificaciones son solo punteros, el cambio de contexto es instantáneo y no requiere mover archivos pesados.

Para obtener más información, consulta nuestro tutorial sobre ramas de Git o consulta nuestra hoja de referencia de Git.

Cómo enumerar las ramas locales en Git

Una vez establecida esta base conceptual, veamos cómo enumerar las ramas locales en tu repositorio.

Una rama local es una rama que existe en tu ordenador. Se encuentra dentro de la carpeta .git de tu repositorio y representa un puntero móvil a una serie de confirmaciones. Puedes cambiar a una rama local, realizar cambios y crear nuevas confirmaciones en ella.

Es útil pensar en las sucursales locales de esta manera:

• Pertenecen a tu copia del repositorio.
• Avanzan cuando se confirman nuevos cambios.
• No se actualizan automáticamente cuando otras personas envían código.

Usando git branch

El comando más común y fundamental para listar las ramas locales es bastante sencillo:

git branch

Cuando ejecutas este comando sin opciones adicionales, Git te muestra todas las ramas locales.

Cosas importantes que debes recordar sobre git branch:

• Solo muestra las ramas locales, no las remotas.
• No se conecta a Internet.
• No cambia los archivos, las confirmaciones ni el historial de las ramas.

Debido a que es seguro y rápido, muchos programadores ejecutan git branch por costumbre antes de comenzar un nuevo trabajo o cambiar de contexto.

Comprender el resultado

Aquí tienes un ejemplo de lo que podría mostrar git branch:

 bugfix/login-timeout
  feature/payment-refactor
* main

Aunque este resultado parece sencillo, hay algunos detalles importantes ocultos en él.

En primer lugar, el asterisco (*) indica la rama que está actualmente seleccionada. Esta es la rama a la que está vinculado tu directorio de trabajo en este momento. Cualquier nuevo commit que crees se incluirá en esta rama.

En segundo lugar, Git suele resaltar la rama actual en verde. Esto es solo una ayuda visual desde la terminal y no cambia el comportamiento de Git.

En tercer lugar, fíjate en lo que no se muestra:

• Sin fechas de compromiso
• Sin nombres de autores
• Sin información remota

Esto es intencionado. Git mantiene la salida predeterminada breve, por lo que es fácil de leer y combinar con otros comandos.

Consejo para principiantes: Si tu terminal parece «atascarse» después de ejecutar un comando Git, prueba a pulsar q. Git suele utilizar un paginador para mostrar resultados largos, y esta es la forma habitual de salir de él.

Obtener solo la rama actual

A veces, no es necesario enumerar todas las ramas. Quizás solo quieras saber en qué rama te encuentras actualmente. Git proporciona un comando específico para esto:

git branch --show-current

El resultado es solo el nombre de la rama:

main

Entre las situaciones habituales en las que esto resulta útil se incluyen:

• Comprobación de la rama antes de enviar el código
• Registrar el nombre de la rama en scripts
• Uso del nombre de la rama en la automatización o en los procesos de integración continua (CI)

Si Git se encuentra en un estado HEAD separado, este comando no devuelve ningún resultado. Aunque al principio pueda parecer extraño, en realidad resulta útil a la hora de escribir scripts que necesitan detectar si se ha extraído una rama.

Error común: Algunos usuarios piensan que Git «no funciona» cuando no aparece ningún nombre de rama. En la mayoría de los casos, esto simplemente significa que no te encuentras actualmente en una rama, sino en una confirmación específica.

Cómo listar las ramas remotas y todas las ramas en Git

Listar las ramas remotas o incluso todas las ramas en Git funciona de manera muy similar a listar las locales.

Listado de ramas remotas en Git

Los repositorios remotos, como los de GitHub o GitLab, tienen sus propias ramas. Para verlos, añade el indicador -r:

git branch -r

  origin/HEAD -> origin/main
  origin/bugfix/login-timeout
  origin/feature/payment-refactor
  origin/main

Este ejemplo de resultado puede resultar confuso al principio, así que vamos a analizarlo.

Lo que estás viendo aquí son ramas de seguimiento remoto. Son referencias locales que Git utiliza para recordar el último estado conocido del repositorio remoto.

Puntos clave para entender:

• Estas ramas se almacenan localmente.
• Solo se actualizan cuando los recuperas.
• No se mueven automáticamente.

Consejo para principiantes: Piensa en las ramas de seguimiento remoto como el cuaderno de Git. Git registra cómo estaba el control remoto la última vez que lo comprobaste, pero no actualizará ese cuaderno a menos que lo recuperes explícitamente.

Listar todas las ramas en Git

Para ver tanto las ramas locales como las ramas de seguimiento remoto juntas, utiliza el indicador ` -a `:

git branch -a

* main
  feature/payment-refactor
  remotes/origin/bugfix/login-timeout
  remotes/origin/main

Esta vista combinada te ayuda a comprender cómo se relacionan tus sucursales locales con las remotas.

Patrones de nomenclatura a tener en cuenta:

• Las ramas locales aparecen como nombres simples, como main

• Las ramas de seguimiento remoto aparecen en remotes/origin/

Esta vista resulta especialmente útil a la hora de decidir si crear una nueva rama local que siga una rama remota existente.

Siempre buscar primero

Si un compañero de equipo publica una nueva rama y tú no puedes verla, la razón más común es que tu caché local está desactualizada. 

La solución es buscar:

git fetch

Qué hace git fetch:

• Descarga la información más reciente de la rama desde el control remoto.
• Actualiza tus ramas de seguimiento remoto.
• Deja tus archivos de trabajo sin cambios.

Este comando se puede ejecutar de forma segura en cualquier momento. No fusiona código ni sobrescribe tu trabajo. Muchos equipos consideran git fetch como un paso rutinario antes de inspeccionar las ramas.

Error común: Los principiantes suelen confundir « git fetch » con « git pull ». Fetch solo obtiene información actualizada de la rama, mientras que pull también fusiona los cambios en tu rama actual.

Cómo obtener más detalles sobre tu lista de ramas de Git

A veces, los nombres de las ramas no son suficientes. Si deseas ver detalles adicionales, hay algunas indicaciones útiles que pueden ayudarte.

Ver las últimas confirmaciones

Para ver qué contiene realmente cada rama, utiliza:

git branch -v

El resultado podría ser similar al siguiente:

* main   a1b2c3d Fix typo in README
  feature/payment-refactor e4f5g6h Refactor payment service

Como puedes ver, la bandera ` -v ` añade un contexto importante:

• El hash de confirmación corto muestra dónde apunta actualmente la rama.
• El mensaje de confirmación da una pista sobre el propósito de la rama.

Esta es una de las formas más sencillas de entender para qué sirve una rama sin tener que comprobarlo.

Consejo para principiantes: Si no estás seguro de si una rama es segura para eliminar, comprobar su último mensaje de confirmación es una buena primera pista.

Comprobación de las conexiones ascendentes

Las ramas locales suelen realizar un seguimiento de la rama remota correspondiente. Para ver esta relación, ejecuta:

git branch -vv

* main   a1b2c3d [origin/main] Fix typo in README
  feature/payment-refactor e4f5g6h [origin/feature/payment-refactor] Refactor payment service

Este resultado te indica:

• ¿A qué rama remota está vinculada tu rama local?

• De dónde se extraerá git pull

• ¿A dónde se dirigirá git push?

Si una rama no tiene upstream, no mostrará nada entre paréntesis. Esto suele explicar los errores de empuje o tracción.

Error común: Intentar ejecutar « git pull » en una rama sin upstream normalmente dará error. En ese caso, primero debes establecer una rama ascendente o enviar la rama por primera vez.

Ordenar ramas por fecha o versión

Para encontrar las ramas activas recientemente, puedes ordenarlas por fecha de confirmación:

git branch --sort=-committerdate

Esto coloca las ramas actualizadas más recientemente en la parte superior y las ramas más antiguas en la parte inferior.

Para repositorios con ramas versionadas, la clasificación semántica resulta más útil:

git branch --sort=v:refname

Esto respeta los números de versión y evita la confusión del orden alfabético.

Cómo filtrar la lista de ramas en Git

Si estás buscando una sucursal específica, el filtrado puede resultar muy útil. Te mostraré cómo hacerlo utilizando algunas opciones importantes.

Búsqueda por patrón de nombre

Especialmente en repositorios grandes, filtrar por nombre puede ahorrarte mucho tiempo a la hora de encontrar la rama correcta. Puedes filtrar por nombre utilizando el indicador --list junto con el término de búsqueda:

git branch --list 'feature/*'

Observa cómo se utiliza « * » como comodín: El resultado aquí solo muestra las ramas que coinciden con el patrón, es decir, las que comienzan por feature. Los equipos suelen utilizar prefijos como feature/, bugfix/ o hotfix/ para mantener todo organizado. Piensa en ellos como carpetas para tus ramas.

Buscar ramas fusionadas frente a ramas sin fusionar

Dos filtros muy importantes son:

git branch --merged
git branch --no-merged

Estos comandos comparan otras ramas con tu rama actual.

• --merged muestra las ramas cuyo trabajo ya está incluido

• --no-merged muestra las ramas que aún contienen confirmaciones únicas

Recordatorio de seguridad: Comprueba siempre que estás en la rama base correcta (a menudo main o develop) antes de utilizar --merged. Los resultados dependen de tu rama actual.

Encontrar qué rama contiene una confirmación

Si conoces un hash de confirmación y deseas encontrar dónde se encuentra, utiliza este comando:

git branch --contains <commit-hash>

Esto resulta útil a la hora de realizar un seguimiento de los errores o verificar que se ha fusionado una corrección.

Por ejemplo, cuando un compañero de trabajo te dice lo siguiente: «He encontrado un error en este hash de confirmación; ¿qué ramas se ven afectadas por él?». Puedes usar este comando para localizar con precisión la ubicación exacta del error.

Combinación de filtros para flujos de trabajo avanzados

Los filtros que te he mostrado se pueden combinar para acotar aún más los resultados. Veamos un ejemplo:

git branch --list 'feature/*' --no-merged

El resultado de este comando muestra rápidamente todas las ramas feature/ sin fusionar y ayuda al equipo a mantenerse organizado.

Solución de problemas comunes

Si tienes problemas, no te preocupes; los más comunes son bastante fáciles de solucionar.

Faltan ramas remotas

Si no puedes ver una rama que otra persona ha enviado, lo más probable es que simplemente hayas olvidado recuperarla. Para solucionar el problema:

1. Corre git fetch

2. A continuación, vuelve a enumerar las ramas.

Si el problema era la falta de recuperación, esta solución rápida actualiza tu vista local de inmediato.

El estado HEAD independiente

A veces, el resultado de « git branch » tiene este aspecto:

* (HEAD detached at a1b2c3d)

Esto significa que no estás en una rama. Estás viendo directamente una confirmación específica.

Estar en un estado HEAD independiente no es peligroso en sí mismo, pero cualquier nuevo commit que realices puede ser difícil de encontrar más adelante a menos que crees una rama.

Para volver al trabajo normal, utiliza checkout para crear una nueva rama:

git checkout <branch-name>

También puedes crear una nueva rama desde tu posición actual utilizando el indicador « -b »:

git checkout -b <new-branch-name>

Las ramas siguen apareciendo después de eliminarlas.

Si las ramas remotas siguen apareciendo después de eliminarlas en el servidor, puedes limpiar su referencia local utilizando el siguiente comando:

git remote prune origin

Esto limpia las referencias obsoletas y mantiene tu repositorio ordenado.

Consejo profesional: Como alternativa, también puedes utilizar git fetch --prune cada vez que realices una recuperación, de modo que el repositorio se actualice y se limpie en un solo paso.

Conclusión

Enumerar las ramas en Git es una habilidad clave que te ayuda a comprender tu repositorio. Los comandos y opciones que se tratan en este tutorial te ayudarán a evitar errores y a trabajar con confianza con otras personas. 

Al iniciar un nuevo proyecto, suele merecer la pena pensar en qué tipo de estructura de ramas vas a necesitar. Para obtener algunos consejos, consulta esta guía sobre la estrategia de ramificación de Git.

¿Estás listo para ir más allá de lo básico? El programa « » ( Fundamentos de Git) de Git Fundamentals ofrece los conceptos y la experiencia práctica necesarios para pasar de principiante a profesional.