Ramas en GitHub

Las ramas permiten trabajar en diferentes versiones de un proyecto sin modificar directamente la rama principal. En GitHub, además de almacenar estas ramas en un repositorio remoto, puedes crearlas, compararlas, fusionarlas, eliminarlas y protegerlas desde la propia plataforma.

1. ¿Qué son las ramas en GitHub?

Una rama en GitHub representa una línea de desarrollo independiente dentro de un repositorio. Permite realizar cambios sin afectar directamente a otra rama, normalmente main.

Nota: si todavía no conoces cómo funcionan las ramas en Git, puedes consultar primero el artículo sobre ramas en Git, donde se explican conceptos como branch, checkout, switch, merge y el trabajo con ramas locales.

Por ejemplo, imagina un proyecto que ya está funcionando correctamente en la rama main. Si quieres agregar una nueva funcionalidad, puedes crear una rama llamada:

nueva-funcionalidad

Los cambios se realizan en esa rama y, una vez terminados y revisados, pueden integrarse nuevamente en main.

1.1. ¿Para qué sirven?

Las ramas son especialmente útiles para:

• Desarrollar nuevas funcionalidades.
• Corregir errores.
• Experimentar con cambios.
• Trabajar en equipo.
• Revisar código antes de incorporarlo a la rama principal.
• Mantener estable la versión principal del proyecto.

En GitHub, las ramas adquieren todavía más importancia porque pueden utilizarse junto con Pull Requests, revisiones de código y reglas de protección.

1.2. Diferencia entre una rama en Git y una rama en GitHub

Aunque hablamos de «ramas en Git» y «ramas en GitHub», técnicamente NO son dos conceptos completamente diferentes.

Git es el sistema de control de versiones que crea y administra ramas, mientras que GitHub es una plataforma que aloja repositorios Git y permite trabajar con esas ramas de forma remota.

Por ejemplo, puedes crear una rama localmente con:

git branch nueva-funcionalidad

O cambiar a ella:

git switch nueva-funcionalidadLenguaje del código: JavaScript (javascript)

Esa rama existe inicialmente en tu repositorio local.

Para enviarla a GitHub puedes utilizar:

git push -u origin nueva-funcionalidad

A partir de ese momento tendrás una rama remota en GitHub asociada con tu rama local.

1.3. Git vs GitHub

Git	GitHub
Es un sistema de control de versiones	Es una plataforma para alojar y colaborar con repositorios Git
Permite crear ramas localmente	Permite administrar ramas desde una interfaz web
Permite hacer merge	Permite hacer merge mediante Pull Requests
Permite comparar ramas localmente	Permite comparar ramas desde GitHub
Permite eliminar ramas locales	Permite eliminar ramas remotas
Funciona desde la terminal	Permite trabajar desde el navegador y otras herramientas

Por eso, cuando trabajas con GitHub, normalmente utilizas Git para gestionar el repositorio local y GitHub para alojarlo y colaborar con otras personas.

2. ¿Cómo funcionan las ramas en GitHub?

El funcionamiento habitual puede representarse de esta manera:

main
 │
 ├── Crear rama
 │
 └── nueva-funcionalidad
       │
       ├── Realizar cambios
       ├── Commit
       └── Push
              │
              ▼
           GitHub
              │
              └── Pull Request
                       │
                       ▼
                  Revisar cambios
                       │
                       ▼
                    Merge
                       │
                       ▼
                      main

La rama permite trabajar de forma independiente y GitHub proporciona las herramientas necesarias para revisar e integrar esos cambios.

3. ¿Cómo crear una rama en GitHub?

Una de las ventajas de GitHub es que puedes crear una rama directamente desde la interfaz web.

Para hacerlo:

1. Entra en el repositorio de GitHub.
2. Selecciona el selector de ramas.
3. Escribe el nombre de la nueva rama.
4. Elige la opción para crear la rama a partir de la rama actual.

Por ejemplo, si estás situado en:

main

puedes crear:

desarrollo-login

La nueva rama partirá del estado que tenga main en ese momento.

3.1. Crear una rama desde Git y enviarla a GitHub

También puedes crear la rama localmente:

git switch -c desarrollo-loginLenguaje del código: JavaScript (javascript)

Después puedes subirla a GitHub:

git push -u origin desarrollo-login

De esta forma, la rama se crea en Git y posteriormente se publica en GitHub.

3.2. ¿Cómo ver las ramas en GitHub?

Para ver las ramas disponibles de un repositorio:

1. Abre el repositorio en GitHub.
2. Selecciona el selector de ramas.
3. Allí podrás consultar las ramas disponibles.

GitHub también dispone de una sección específica para administrar las ramas del repositorio.

Esto resulta especialmente útil cuando un proyecto tiene muchas ramas y necesitas localizar una rama concreta.

3.3. ¿Cómo cambiar de rama en GitHub?

En GitHub puedes cambiar la rama que estás visualizando utilizando el selector de ramas.

Por ejemplo:

main
desarrollo
nueva-funcionalidad
correccion-error

Si seleccionas:

nueva-funcionalidad

GitHub mostrará los archivos y commits correspondientes a esa rama.

3.4. Cambiar de rama localmente

Cuando trabajas desde tu computadora, el cambio de rama se realiza mediante Git:

git switch nueva-funcionalidadLenguaje del código: JavaScript (javascript)

También puedes hacerlo desde Visual Studio Code utilizando el selector de ramas de la interfaz.

4. ¿Cómo es el flujo de trabajo con ramas en GitHub?

Un flujo de trabajo habitual puede ser:

4.1. Partir de main

Primero asegúrate de tener actualizada la rama principal:

git switch main
git pullLenguaje del código: JavaScript (javascript)

4.2. Crear una nueva rama

git switch -c nueva-funcionalidadLenguaje del código: JavaScript (javascript)

4.3. Realizar los cambios

Modifica los archivos necesarios del proyecto.

4.4. Crear un commit

git add .
git commit -m "Agregar nueva funcionalidad"Lenguaje del código: JavaScript (javascript)

4.5. Subir la rama a GitHub

git push -u origin nueva-funcionalidad

4.6. Crear un Pull Request

Una vez que la rama está en GitHub, puedes crear un Pull Request para solicitar que los cambios sean incorporados a main.

Este flujo es muy utilizado en proyectos colaborativos porque permite revisar los cambios antes de incorporarlos a la rama principal.

5. ¿Cómo comparar ramas en GitHub?

GitHub permite comparar dos ramas para conocer exactamente qué diferencias existen entre ellas antes de integrar sus cambios. Esta función resulta especialmente útil para revisar una nueva funcionalidad, comprobar qué archivos fueron modificados o preparar un Pull Request.

5.1. Entrar al repositorio

Accede al repositorio de GitHub donde se encuentran las ramas que quieres comparar.

Por ejemplo, puedes tener:

main
feature-login

En este caso, podrías querer comprobar qué cambios contiene feature-login que todavía no están en main.

5.2. Seleccionar la opción para comparar ramas

En el repositorio, puedes acceder a la sección Compare para seleccionar las ramas que quieres analizar.

GitHub permite establecer una rama como referencia (base) y otra como rama de comparación (compare).

Por ejemplo:

base:    main
compare: feature-loginLenguaje del código: HTTP (http)

Esto permite analizar los cambios que existen en feature-login respecto de main.

5.3. Revisar los cambios

GitHub mostrará información sobre las diferencias entre ambas ramas.

Puedes consultar:

• Los archivos modificados.
• Las líneas de código agregadas.
• Las líneas eliminadas.
• Los commits que existen en una rama y no en la otra.
• Los cambios que podrían incorporarse mediante un Pull Request.

Visualmente, GitHub representa las diferencias entre las versiones para facilitar su revisión.

5.4. Interpretar la comparación

Supongamos que main contiene:

index.html
style.css
script.jsLenguaje del código: CSS (css)

Mientras que feature-login contiene además cambios en:

index.html
login.js
style.cssLenguaje del código: CSS (css)

Al comparar ambas ramas, GitHub te permitirá identificar qué se modificó y qué archivos son diferentes.

Esto permite revisar el trabajo antes de fusionarlo.

5.5. Comparar ramas antes de crear un Pull Request

La comparación de ramas está directamente relacionada con los Pull Requests.

Un flujo habitual sería:

feature-login
      │
      │ Comparar con main
      ▼
   Revisar cambios
      │
      ▼
 Pull Request
      │
      ▼
    Merge
      │
      ▼
     main

Antes de realizar el merge, puedes comprobar que los cambios de la rama contienen exactamente lo que esperas incorporar al proyecto.

¿También puedo comparar ramas desde la terminal?

Sí. Git también permite comparar ramas localmente mediante git diff.

Por ejemplo:

git diff main..feature-loginLenguaje del código: CSS (css)

Esto muestra las diferencias entre main y feature-login en tu repositorio local.

La diferencia principal es que Git realiza la comparación localmente, mientras que GitHub permite hacerlo desde la plataforma web y utilizar ese resultado como parte del proceso de revisión y Pull Request.

Consejo: antes de fusionar una rama importante, compara sus cambios con la rama de destino. Esto ayuda a detectar modificaciones inesperadas y posibles conflictos antes de realizar el merge.

6. ¿Cómo hacer merge de ramas en GitHub?

En GitHub, una forma habitual de fusionar ramas es mediante un Pull Request.

Por ejemplo:

main
  │
  └──── nueva-funcionalidad
              │
              │ cambios
              ▼
        Pull Request
              │
              ▼
            Merge
              │
              ▼
             main

El proceso habitual es:

1. Crear una rama.
2. Realizar cambios.
3. Subir la rama a GitHub.
4. Crear un Pull Request.
5. Revisar los cambios.
6. Resolver posibles conflictos.
7. Aprobar el Pull Request.
8. Realizar el merge.
9. Eliminar la rama si ya no es necesaria.

GitHub ofrece diferentes estrategias para realizar el merge, dependiendo de la configuración del repositorio.

6.1. ¿Es lo mismo que git merge?

No exactamente.

Localmente puedes realizar:

git merge nueva-funcionalidad

Mientras que en GitHub puedes integrar los cambios mediante un Pull Request.

Ambos procesos tienen como objetivo incorporar los cambios de una rama en otra, pero el Pull Request añade herramientas de colaboración como revisión de código, comentarios y comprobaciones automáticas.

7. ¿Cómo eliminar ramas en GitHub?

Cuando una rama ya no es necesaria, puedes eliminarla del repositorio de GitHub para mantenerlo organizado. Esto es habitual después de completar y fusionar una funcionalidad mediante un Pull Request.

Por ejemplo, después de fusionar:

feature-login → main

la rama feature-login puede eliminarse si ya no vas a utilizarla.

7.1. Eliminar una rama desde GitHub

Para eliminar una rama directamente desde GitHub:

1. Entra en el repositorio.
2. Accede a la sección Branches.
3. Busca la rama que quieres eliminar.
4. Haz clic en el icono de eliminación de esa rama.
5. Confirma la eliminación.

También puedes eliminar una rama desde el propio Pull Request después de realizar el merge. GitHub ofrece normalmente la opción Delete branch una vez que la rama ha sido fusionada.

7.2. Eliminar una rama mediante Git

Si prefieres utilizar la terminal, puedes eliminar la rama remota de GitHub con:

git push origin --delete feature-loginLenguaje del código: JavaScript (javascript)

Por ejemplo:

git push origin --delete formulario-contactoLenguaje del código: JavaScript (javascript)

Este comando elimina formulario-contacto del repositorio remoto.

7.3. Eliminar también la rama local

Eliminar una rama de GitHub no elimina automáticamente la copia local que tienes en tu computadora.

Para eliminarla localmente puedes utilizar:

git branch -d feature-login

Por ejemplo:

git branch -d formulario-contacto

De esta manera, puedes terminar con ambas ramas eliminadas:

Computadora                     GitHub

feature-login  ❌               feature-login  ❌

7.4. ¿Qué pasa si la rama todavía tiene cambios sin fusionar?

Git puede impedir la eliminación de una rama local si contiene cambios que todavía no han sido fusionados.

Por ejemplo:

git branch -d feature-login

Si Git detecta que podrías perder commits, mostrará un aviso y no eliminará la rama.

Si estás completamente seguro de que quieres eliminarla, puedes utilizar:

git branch -D feature-login

⚠️ La opción -D fuerza la eliminación de la rama local, por lo que debes utilizarla con cuidado.

7.5. ¿Se puede recuperar una rama eliminada?

Si la rama fue eliminada después de realizar un merge mediante un Pull Request, GitHub puede conservar información suficiente para consultar los cambios y, en determinados casos, restaurar la rama.

Por eso, eliminar una rama después de fusionarla no significa necesariamente que desaparezca todo el historial de sus cambios. Los commits que fueron incorporados a main continúan formando parte del historial.

7.6. ¿Cuándo conviene eliminar una rama?

Es recomendable eliminar una rama cuando:

• La funcionalidad ya fue incorporada mediante un merge.
• El error que solucionaba ya está corregido.
• La rama era temporal.
• Ya no contiene trabajo pendiente.
• El proyecto acumula demasiadas ramas antiguas.

Por ejemplo:

main
│
├── feature-login      → Merge → ❌ eliminar
├── feature-perfil     → Merge → ❌ eliminar
└── fix-menu           → En desarrollo

En este caso, feature-login y feature-perfil ya no son necesarias, mientras que fix-menu debe conservarse porque todavía está en desarrollo.

Consejo: elimina las ramas que ya no necesites después de completar su trabajo, pero evita hacerlo si contienen cambios que todavía no fueron integrados y que podrías necesitar posteriormente.

8. ¿Cómo proteger ramas en GitHub?

Una de las funciones más importantes de GitHub para proyectos colaborativos es la posibilidad de proteger determinadas ramas.

Normalmente se protege la rama principal:

main

La protección permite establecer reglas para evitar cambios accidentales o no revisados.

⚠️ Para configurar la protección de una rama:

1. Entra en el repositorio de GitHub.
2. Accede a Settings.
3. Busca la sección relacionada con las reglas del repositorio.
4. Crea una nueva regla para la rama que quieres proteger.
5. Indica la rama o patrón de ramas al que se aplicará.
6. Selecciona las restricciones que quieres utilizar.
7. Guarda la configuración.

Por ejemplo, puedes aplicar la regla a:

main

De esta forma, las condiciones configuradas afectarán a la rama principal.

Dependiendo de la configuración del repositorio, puedes establecer requisitos como:

• Exigir Pull Requests.
• Solicitar revisiones antes del merge.
• Exigir determinadas comprobaciones automáticas.
• Evitar que determinados usuarios hagan cambios directamente.
• Impedir determinados tipos de eliminación o modificaciones.

Por ejemplo, una organización puede configurar el repositorio para que nadie pueda incorporar cambios directamente a main y todos los cambios tengan que pasar primero por un Pull Request.

Esto ayuda a mantener estable la rama principal.

9. Buenas prácticas

Al trabajar con ramas es recomendable seguir algunas prácticas:

Buena práctica	Beneficio
Utilizar nombres descriptivos	Facilita identificar el objetivo de cada rama
Crear ramas para funcionalidades	Evita modificar directamente main
Mantener las ramas actualizadas	Reduce posibles conflictos
Utilizar Pull Requests	Facilita la revisión de código
Proteger main	Evita cambios accidentales
Eliminar ramas terminadas	Mantiene el repositorio organizado
Realizar commits claros	Facilita comprender el historial
Evitar ramas demasiado grandes	Hace más sencilla la revisión

Por ejemplo, en lugar de utilizar:

rama1
prueba
cambios
nueva

es preferible utilizar nombres que indiquen claramente el propósito:

feature-login
feature-carrito
fix-menu-mobile
fix-error-registro

10. Errores comunes

Al comenzar a trabajar con ramas es habitual cometer algunos errores.

1. 14.1. Trabajar directamente sobre main
   • Puede provocar que cambios incompletos lleguen a la rama principal.
2. Crear demasiadas ramas sin eliminarlas
   • Con el tiempo, el repositorio puede terminar lleno de ramas antiguas que ya no tienen utilidad.
3. No actualizar la rama antes de trabajar
   • Si la rama parte de una versión antigua del proyecto, pueden aparecer conflictos posteriormente.
4. Confundir ramas locales y remotas
   • Una rama creada con:

git branch nueva-rama

• no aparece automáticamente en GitHub.
• Es necesario publicarla, por ejemplo:

git push -u origin nueva-rama

5. Hacer merge sin revisar los cambios
   • Antes de integrar una rama es recomendable comparar los cambios y comprobar que todo funciona correctamente.

11. Resumen

Las ramas son una funcionalidad de Git, pero GitHub añade una capa de colaboración y administración sobre ellas.

Con Git puedes:

git branch
git switch
git merge
git push
git pullLenguaje del código: JavaScript (javascript)

Mientras que GitHub permite, además:

• Crear ramas desde la interfaz web.
• Visualizar y comparar ramas.
• Crear Pull Requests.
• Revisar código.
• Aprobar cambios.
• Fusionar ramas.
• Proteger ramas.
• Administrar ramas remotas.

Por eso, si ya aprendiste a trabajar con ramas en Git, no necesitas volver a aprender el concepto desde cero para utilizar ramas en GitHub. Lo importante en este punto es entender cómo GitHub utiliza esas ramas dentro de un flujo de trabajo colaborativo.

Flujo resumido

Crear rama
    ↓
Trabajar en ella
    ↓
Commit
    ↓
Push a GitHub
    ↓
Pull Request
    ↓
Revisión
    ↓
Merge
    ↓
Eliminar rama

Este flujo será especialmente importante en los siguientes artículos del curso, donde puedes profundizar en Pull Requests, merge de Pull Requests y resolución de conflictos en GitHub.