Guía de Branches en Git y GitHub

1. Introducción a las ramas

¿Qué es una rama (branch)?

Una rama (branch) es una línea independiente de desarrollo en Git. Imagina que tu proyecto es como una línea de tiempo: en lugar de escribir todo linealmente, las ramas te permiten crear caminos alternativos para trabajar en diferentes características, sin afectar el flujo principal de tu código.

¿Por qué se utilizan las ramas?

Trabajo en equipo

Varios desarrolladores pueden trabajar simultáneamente en diferentes funcionalidades sin conflictos.

Estabilidad

El código principal (main) siempre funciona, mientras desarrollas en ramas separadas.

Organización

Cada feature o fix se desarrolla en su propia rama, manteniendo el proyecto organizado.

Control

Revisa cambios antes de fusionar (merge) con el código principal usando Pull Requests.

Comparación: Sin ramas vs Con ramas

Sin ramas

Todo el trabajo ocurre en main:

Código incompleto va al repositorio principal
Difícil colaborar sin conflictos
No hay control sobre qué se incluye
Difícil revertir cambios específicos

Con ramas

Cada feature en su propia rama:

Código limpio y funcional en main
Fácil colaboración entre desarrolladores
Revisiones antes de fusionar
Historial claro de cambios

Ejemplo práctico: Proyecto con múltiples funcionalidades

main (rama principal - código en producción)
  │
  ├── feature/login (Juan está aquí)
  │   └── Implementando sistema de autenticación
  │
  ├── feature/carrito (María está aquí)
  │   └── Desarrollando carrito de compras
  │
  └── bugfix/homepage (Pedro está aquí)
      └── Arreglando error en la portada

Ventaja clave: Juan, María y Pedro pueden trabajar simultáneamente sin interferir uno con otro. Luego, sus cambios se fusionan ordenadamente a main.

2. Visualización de ramas

Ver las ramas locales

Para ver todas las ramas que existen en tu repositorio local, usa:

$ git branch

develop feature/usuarios * main staging

Significado del símbolo *

El asterisco (*) indica tu rama actual. En el ejemplo anterior, estás trabajando en main. Si haces cambios, se guardarán en esta rama.

Más opciones útiles

Comando	Descripción
`git branch -a`	Muestra todas las ramas (locales y remotas)
`git branch -r`	Muestra solo ramas remotas (en GitHub)
`git branch -v`	Muestra ramas con el último commit de cada una
`git branch -d nombre`	Elimina una rama (veremos después)

3. Creación de ramas

¿Cómo crear una rama?

Crear una rama es simple: le das un nombre descriptivo basado en lo que vas a trabajar. La nueva rama será una copia del estado actual de tu rama.

Comando básico

$ git branch usuarios

¿Qué sucede?

Se crea una nueva rama llamada usuarios, pero aún sigues en tu rama actual. Para verificar:

$ git branch

* main usuarios

El asterisco sigue en main, así que aún estás aquí.

Convenciones de nombres para ramas

Recomendaciones:

feature/nombre-funcionalidad — Para nuevas características
bugfix/nombre-bug — Para arreglat errores
hotfix/nombre-urgente — Para arreglos urgentes en producción
refactor/nombre-cambio — Para mejoras de código
Usa guiones, no espacios ni mayúsculas

Ejemplos prácticos

git branch feature/login — Crear rama para sistema de login

git branch bugfix/carrito-error — Crear rama para fix de carrito

git branch refactor/estilos-css — Crear rama para refactorizar CSS

4. Cambio entre ramas

Moverse entre ramas

Crear una rama no te coloca automáticamente en ella. Necesitas cambiar a esa rama para empezar a trabajar. Hay dos formas de hacerlo:

Opción 1: git checkout

$ git checkout usuarios

Switched to branch 'usuarios'

Ahora verifica:

$ git branch

main * usuarios

Opción 2: git switch (más moderno)

$ git switch usuarios

Switched to branch 'usuarios'

Diferencias entre checkout y switch

Aspecto	git checkout	git switch
Antigüedad	Más antiguo (tradicional)	Más nuevo (Git 2.23+)
Uso principal	Cambiar ramas y deshacer cambios	Solo cambiar ramas
Claridad	Menos clara (múltiples funciones)	Más clara (solo cambia ramas)
Recomendación	Funciona bien	✓ Mejor para cambiar ramas

Para este curso: Usaremos ambas, pero git switch es más moderno y recomendado.

5. Crear y cambiar de rama en un solo comando

¿Por qué combinarlo?

Normalmente, crear una rama y cambiar a ella son acciones consecutivas. Git permite hacerlas juntas con un solo comando, que es mucho más eficiente.

Opción 1: git checkout -b

$ git checkout -b feature/usuarios

Switched to a new branch 'feature/usuarios'

Esto crea la rama feature/usuarios y te cambia a ella automáticamente.

Opción 2: git switch -c (más moderno)

$ git switch -c feature/usuarios

Switched to a new branch 'feature/usuarios'

Comparación

git checkout -b

Comando que conocemos desde hace años. Funciona perfectamente.

git switch -c

Sintaxis más clara. -c significa "create" (crear).

Ejemplos prácticos

git checkout -b bugfix/error-login — Crear y cambiar a rama de fix

git switch -c feature/carrito-compras — Crear y cambiar a rama de feature

Consejo profesional: La mayoría del flujo de trabajo usa esta forma combinada.

6. Verificar la rama actual

Método 1: git branch

$ git branch

main * feature/usuarios

El asterisco muestra que estás en feature/usuarios.

Método 2: git status

$ git status

On branch feature/usuarios Your branch is up to date with 'origin/feature/usuarios'. nothing to commit, working tree clean

git status nos muestra en qué rama estamos y también información sobre cambios no commitidos.

¿Cuándo usar cada uno?

Comando	Información que da	Mejor para
`git branch`	Solo lista de ramas	Ver todas las ramas disponibles
`git status`	Rama actual + cambios pendientes	Ver estado completo del repositorio

7. Trabajo dentro de una rama

Cada rama es independiente

Cuando estás en una rama, todos tus cambios afectan solo a esa rama. El código en main permanece intacto. Esto es la magia de las ramas: aislamiento total.

Flujo de trabajo típico

Asume que estamos en feature/usuarios:

Edita archivos

Abre tu editor y realiza cambios en los archivos de tu proyecto.

Verifica cambios

$ git status

On branch feature/usuarios Changes not staged for commit: modified: app.js modified: style.css

Agrega cambios al área de preparación

$ git add .

. significa "todos los archivos modificados"

Crea un commit (snapshot)

$ git commit -m "Agregar formulario de registro"

[feature/usuarios abc1234] Agregar formulario de registro 2 files changed, 45 insertions(+), 12 deletions(-)

¿Qué hace cada comando?

Comando	Función	Ejemplo
`git add .`	Prepara TODOS los cambios para guardar	`git add .`
`git add archivo.js`	Prepara UN archivo específico	`git add app.js`
`git commit -m "msg"`	Guarda (hace snapshot) con un mensaje	`git commit -m "Agregar login"`

Mensaje de commit claro: Usa verbos en imperativo: "Agregar", "Corregir", "Refactorizar", no "Agregado", "Corregido".

8. Subir una rama a GitHub

Diferencia: Local vs Remoto

Repositorio Local

Tus ramas y cambios en tu computadora (invisible para el equipo).

Repositorio Remoto

Tus ramas en GitHub (visible para todos los colaboradores).

El comando para subir

$ git push -u origin feature/usuarios

Enumerating objects: 5, done. Counting objects: 100% (5/5), done. Delta compression using up to 8 threads Compressing objects: 100% (3/3), done. Writing objects: 100% (3/3), 298 bytes To github.com:tu-usuario/tu-repo.git * [new branch] feature/usuarios -> feature/usuarios Branch 'feature/usuarios' set up to track 'origin/feature/usuarios'.

Desglose del comando

Parte	Significado
`git push`	Subir cambios al repositorio remoto
`-u`	Flag que configura esta rama como "seguida" (próximas veces solo necesitas `git push`)
`origin`	Nombre del repositorio remoto (por defecto, es GitHub)
`feature/usuarios`	Nombre de la rama que estás subiendo

¿Qué ocurre en GitHub?

Después de ejecutar el comando, tu rama aparece en GitHub:

Puedes ver tu rama en la pestaña de "Branches"
GitHub te sugiere crear un Pull Request automáticamente
Tu equipo puede ver tu trabajo en progreso

Proximas veces

Una vez que configuraste con -u, los próximos push son más simples:

$ git push

Git sabe automáticamente a dónde subir.

9. Descargar información de GitHub

git fetch: Sincronizar sin descargar

git fetch descarga toda la información de GitHub (ramas nuevas, cambios del equipo) pero no modifica tu código.

$ git fetch

remote: Counting objects: 5, done. remote: Compressing objects: 100% (3/3), done. From github.com:tu-usuario/tu-repo abc1234..def5678 main -> origin/main * [new branch] feature/carrito -> origin/feature/carrito

Ver ramas remotas

Para ver qué ramas existen en GitHub después de fetch:

$ git branch -r

origin/HEAD -> origin/main origin/feature/carrito origin/feature/usuarios origin/main origin/staging

Desglose de la salida

origin/ indica que es una rama remota (en GitHub)
origin/HEAD es la rama por defecto del repositorio remoto
Cada rama que ves es una rama que existe en GitHub

Diferencia importante:

git branch — Solo ramas locales
git branch -r — Solo ramas remotas
git branch -a — Todas las ramas (locales + remotas)

10. Trabajar con ramas remotas

Obtener una rama del repositorio remoto

Cuando tu compañero sube una rama a GitHub, quizá necesites trabajar con esa rama. Primero, debes descargarla localmente:

$ git fetch

Luego, crea una rama local que siga la rama remota:

$ git checkout -b feature/carrito origin/feature/carrito

Branch 'feature/carrito' set up to track 'origin/feature/carrito'

Desglose del comando

Parte	Significado
`git checkout -b`	Crear y cambiar a una rama nueva
`feature/carrito`	Nombre de la rama LOCAL que vas a crear
`origin/feature/carrito`	Rama REMOTA que vas a seguir (la fuente)

Forma más simple (Git 2.23+)

Si usas Git moderno, Git es lo suficientemente inteligente para hacerlo solo:

$ git switch feature/carrito

Branch 'feature/carrito' set up to track 'origin/feature/carrito' Switched to a new branch 'feature/carrito'

Git automáticamente busca una rama remota con ese nombre y la descarga.

Consejo: Usa git switch cuando quieras trabajar con una rama remota. Es más simple.

11. Fusionar ramas (Merge)

¿Qué es un merge?

Merge significa "fusión". Es el proceso de combinar los cambios de una rama con otra (típicamente, mezclar una feature branch con main).

¿Cuándo se utiliza?

Cuando terminas una feature: La merge a main para que esté en producción
Cuando aceptas cambios: Un compañero finalizó su trabajo, lo merges a main
Cuando sincronizas: Main tiene cambios nuevos, los traes a tu rama

Flujo de merge paso a paso

1. Cambia a la rama de destino (main)

$ git switch main

Switched to branch 'main'

2. Descarga los cambios más recientes de GitHub

$ git pull

Already up to date.

3. Fusiona la rama que terminaste

$ git merge feature/usuarios

Updating abc1234..def5678 Fast-forward app.js | 25 +++++++++++++++++++++++++ style.css | 15 ++++++++++++++++++ 2 files changed, 40 insertions(+)

Diagrama visual del merge

Antes del merge:
main         →  Commit A
feature/usuarios → Commit B (cambios nuevos)

Después del merge:
main         →  Commit A - Commit B ✓
feature/usuarios → Commit B (todavía aquí)

El código de feature/usuarios ahora está en main

Tipos de merge

1. Fast-forward (el más común)

Git simplemente mueve el apuntador de main. No hay conflictos.

Resultado: Historial limpio y lineal

2. Merge commit (cuando hay cambios paralelos)

Git crea un commit especial que une dos líneas de código.

Cuando ocurre: Main y feature/usuarios tienen commits diferentes

¿Qué pasa si hay conflictos?

Si Git no puede fusionar automáticamente (conflicto), te lo notifica. Veremos esto en profundidad en lecciones posteriores.

Importante: Siempre asegúrate de estar en main y haber hecho git pull antes de mergear.

12. Subir el resultado del merge

Después de mergear localmente

Una vez que mezclaste tu rama en main, los cambios están en tu computadora pero aún no en GitHub. Debes subirlos:

$ git push

Enumerating objects: 5, done. Counting objects: 100% (5/5), done. Compressing objects: 100% (2/2), done. Writing objects: 100% (3/3), 298 bytes To github.com:tu-usuario/tu-repo.git abc1234..def5678 main -> main

¿Qué cambios llegan a GitHub?

Todos los commits de feature/usuarios ahora están en main
El historial de main se actualiza
Tu equipo puede ver los cambios en GitHub
Usuarios en producción pueden recibir la versión actualizada (si se despliega desde main)

Éxito: Tu feature está oficialmente en el repositorio compartido. El equipo puede verlo y utilizarlo.

13. Eliminación de ramas

¿Por qué eliminar ramas?

Una vez que mergeas una rama, ya no la necesitas. Mantener ramas antiguas hace el proyecto confuso. Buena práctica: eliminar ramas después de usarlas.

Eliminar rama local (segura)

$ git branch -d feature/usuarios

Deleted branch feature/usuarios (was def5678).

El flag -d (delete) elimina la rama solo si ya fue mergeada. Es segura.

Forzar eliminación (peligrosa)

$ git branch -D feature/usuarios

Deleted branch feature/usuarios (was def5678).

El flag -D (Delete forzado) elimina la rama SIN verificar si fue mergeada. ¡Cuidado!

Eliminar rama remota (en GitHub)

$ git push origin --delete feature/usuarios

To github.com:tu-usuario/tu-repo.git - [deleted] feature/usuarios

Esto elimina la rama en GitHub (pero la tuya local sigue existiendo).

Tabla de decisión

Situación	Comando	Seguridad
Branch local mergeada	`git branch -d nombre`	✓ Segura
Branch local SIN mergear (error)	`git branch -D nombre`	⚠️ Cuidado
Branch remota en GitHub	`git push origin --delete nombre`	✓ Elimina en GitHub

Flujo completo: Primero elimina la local (-d), luego la remota (git push origin --delete).

14. Flujo completo de trabajo: Ejemplo "Login"

Escenario

Necesitas implementar un sistema de login en tu sitio. Harás todo desde git clone hasta eliminar la rama. Veamos paso a paso:

Clonar el repositorio

$ git clone https://github.com/tu-usuario/tu-repo.git

Cloning into 'tu-repo'... remote: Counting objects: 100, done. Resolving deltas: 100% (45/45), done.

Esto descarga todo el repositorio en una carpeta local.

Entrar a la carpeta

$ cd tu-repo

Crear una rama para login

$ git switch -c feature/login

Switched to a new branch 'feature/login'

Desarrollar la funcionalidad

Abre tu editor y crea/modifica archivos (login.html, login.js, login.css, etc.)

$ git status

On branch feature/login Changes not staged for commit: modified: index.html new file: login.html new file: login.js

Preparar cambios

$ git add .

Crear commit descriptivo

$ git commit -m "Implementar sistema de login con HTML, JS y estilos"

[feature/login abc1234] Implementar sistema de login 3 files changed, 150 insertions(+), 12 deletions(-)

Subir rama a GitHub

$ git push -u origin feature/login

Enumerating objects: 5, done. To github.com:tu-usuario/tu-repo.git * [new branch] feature/login -> feature/login

Cambiar a main

$ git switch main

Switched to branch 'main'

Actualizar main con cambios remotos

$ git pull

Already up to date.

Fusionar la rama

$ git merge feature/login

Updating abc1234..def5678 Fast-forward index.html | 2 +- login.html | 45 +++++++++++++++++++++ login.js | 95 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 141 insertions(+), 1 deletion(-)

Subir el merge a GitHub

$ git push

To github.com:tu-usuario/tu-repo.git abc1234..def5678 main -> main

Eliminar la rama (ya no la necesitas)

$ git branch -d feature/login

Deleted branch feature/login (was def5678).

Eliminar rama remota también

$ git push origin --delete feature/login

To github.com:tu-usuario/tu-repo.git - [deleted] feature/login

¡Listo! Tu feature de login está completamente integrada en main y la rama fue eliminada.

15. Pull Requests

¿Qué es un Pull Request?

Un Pull Request (PR) es una solicitud formal para mergear tu rama en main. En lugar de mergear localmente, abres una PR en GitHub para que otros revisen tu código antes de aceptarlo.

¿Por qué usar Pull Requests?

Revisión de código

Otros pueden ver y comentar tus cambios antes de mergearse.

Aprobación

Solo se acepta código que fue revisado y aprobado.

Automatización

Tests automáticos se ejecutan antes de mergear.

Historial

Queda un registro de quién aprobó qué cambios.

Flujo de trabajo con Pull Requests

Paso 1: Crear y cambiar a rama (como siempre)

$ git switch -c feature/panel-admin

Switched to a new branch 'feature/panel-admin'

Paso 2: Hacer cambios y commits

$ git add .

$ git commit -m "Agregar panel de administración con tablas"

Paso 3: Subir rama a GitHub

$ git push -u origin feature/panel-admin

Paso 4: Abrir Pull Request en GitHub

Ve a GitHub en tu navegador
Verás un botón verde "Compare & pull request"
Haz clic y rellena:
- Título: Resumen breve de cambios
- Descripción: Explicar qué, por qué y cómo
Haz clic en "Create pull request"

En el Pull Request

Después de crear el PR:

Tu equipo ve los cambios en la pestaña "Files changed"
Pueden comentar líneas específicas de código
Tests automáticos se ejecutan (si están configurados)
Alguien revisa y aprueba el PR (o pide cambios)

Flujo de aprobación

TÚ: Creas PR con tu rama
    ↓
REVISOR: Lee código, comenta
    ↓
TÚ: Realizas cambios solicitados, haces push
    ↓
REVISOR: Aprueba el PR
    ↓
ALGUIEN: Haz clic en "Merge pull request"
    ↓
GITHUB: Automáticamente mergea feature→main

Ventajas sobre merge local

Aspecto	Merge local	Pull Request
Revisión	No hay	✓ Formal y asincrónica
Documentación	Mínima	✓ Completa con comentarios
Historial	Básico	✓ Detallado con decisiones
Equipo pequeño	Ágil	Overhead
Equipo grande	Caos	✓ Esencial

Recomendación profesional: Para equipos, siempre usa Pull Requests. Para proyectos personales, merge local es más ágil.

Resumen: Cómo es distinto con PRs

En lugar de:

git switch main → git pull → git merge feature → git push → git branch -d

Haces:

git push → abrir PR en GitHub → esperar aprobación → GitHub hace el merge automático → eliminar rama

Resumen: Comandos clave a recordar

Acción	Comando	Cuándo
Ver ramas locales	`git branch`	Verificar dónde estás
Crear rama	`git branch nombre`	Antes de cambiar a ella
Cambiar de rama	`git switch nombre`	Antes de trabajar
Crear y cambiar	`git switch -c nombre`	Forma más rápida (recomendada)
Preparar cambios	`git add .`	Después de editar archivos
Crear commit	`git commit -m "msg"`	Guardar un checkpoint
Subir a GitHub	`git push -u origin nombre`	Primera vez en una rama
Subir cambios	`git push`	Cambios posteriores
Descargar cambios	`git fetch`	Ver qué hay nuevo en GitHub
Ver ramas remotas	`git branch -r`	Después de fetch
Trabajar rama remota	`git switch nombre`	Descargar rama de compañero
Fusionar rama	`git merge nombre`	Estar en main, luego mergear
Eliminar rama local	`git branch -d nombre`	Después de mergear
Eliminar rama GitHub	`git push origin --delete nombre`	Limpiar repositorio remoto

¡Felicidades! Ahora entiendes cómo funcionan las ramas en Git. Practica estos comandos y pronto serán como segunda naturaleza. Recuerda: las ramas son seguras de usar, no tengas miedo de experimentar.