Ramas y merge

Imagina que quieres añadir un modo oscuro a tu proyecto cafe-estelar. Podrías hacer los cambios directamente en tu código principal, pero... ¿y si algo sale mal? ¿Y si rompes lo que ya funciona? Las ramas (branches) te permiten experimentar en una copia paralela de tu proyecto sin tocar lo que ya tienes estable. Si el experimento funciona, lo fusionas. Si no, lo descartas sin consecuencias.

¿Qué es una rama?

Piensa en las ramas como partidas guardadas en un videojuego. Tienes tu partida principal con todo tu progreso. Antes de enfrentarte al jefe final, guardas la partida en otro slot. Si pierdes, vuelves al slot seguro. Si ganas, ese slot se convierte en tu progreso principal.

En Git funciona igual: una rama es una línea de tiempo paralela de tu proyecto. Puedes crear una rama, hacer todos los cambios que quieras, y cuando estés satisfecho, fusionarla con la rama principal. Si no te convence, simplemente la borras.

La rama principal: main

Cuando inicias un repositorio con git init, Git crea automáticamente una rama llamada main (en versiones antiguas se llamaba master). Esta es tu versión estable — el código que funciona, que está probado, que no da sorpresas.

Regla de oro: nunca trabajes directamente en main. Siempre crea una rama nueva para cada cambio importante. Así main siempre estará limpia y funcional.

Ver las ramas: git branch

Para ver en qué rama estás y qué ramas existen:

git branch

El resultado te mostrará algo así:

* main

El asterisco * indica en qué rama estás ahora mismo. Si solo tienes una rama, verás únicamente main.

Crear una rama nueva

Para crear una nueva rama sin moverte a ella:

git branch feature/dark-mode

Esto crea la rama feature/dark-mode, pero sigues en main. Es como crear un nuevo slot de guardado sin cargar la partida todavía.

Cambiar de rama: git switch

Para moverte a la rama que acabas de crear:

# Forma moderna (recomendada)
git switch feature/dark-mode

# Forma clásica (también funciona)
git checkout feature/dark-mode

Te recomiendo usar git switch — es el comando moderno que Git creó específicamente para cambiar de rama. git checkout hace demasiadas cosas y puede confundirte más adelante.

Y el atajo que más vas a usar: crear y cambiar de rama en un solo paso:

# Crear la rama y moverte a ella de una vez
git switch -c feature/dark-mode

El -c significa "create". Este es el comando que usarás el 90% de las veces.

Trabajar en la rama

Una vez en tu rama, trabajas con total normalidad: editas archivos, haces git add, haces git commit. Todos esos cambios quedan solo en esta rama. Vamos a añadir un modo oscuro a cafe-estelar:

/* Modo oscuro para cafe-estelar */
.dark-mode {
    --color-fondo: #1a1a2e;
    --color-texto: #e0e0e0;
    --color-primario: #c4a35a;
    --color-tarjeta: #16213e;
}

.dark-mode body {
    background-color: var(--color-fondo);
    color: var(--color-texto);
}

.dark-mode .menu-card {
    background-color: var(--color-tarjeta);
    border-color: var(--color-primario);
}

Ahora guardamos los cambios en la rama:

git add styles.css
git commit -m "feat: añadir modo oscuro con variables CSS"

Volver a main: la magia

Aquí viene lo que sorprende a todo el mundo la primera vez. Vuelve a main:

git switch main

Ahora abre styles.css. El código del modo oscuro ha desaparecido. No te asustes — sigue existiendo en la rama feature/dark-mode. En main, todo está exactamente como lo dejaste antes de crear la rama. Es como cargar tu partida guardada original: el progreso del otro slot no afecta a este.

Fusionar ramas: git merge

Tu modo oscuro funciona perfecto y quieres incorporarlo a la versión estable. Para eso usas git merge. Primero asegúrate de estar en la rama que recibe los cambios (en este caso main):

# Asegúrate de estar en main
git switch main

# Fusionar los cambios de feature/dark-mode
git merge feature/dark-mode

Git fusionará los cambios de feature/dark-mode en main. Hay dos formas en que esto puede ocurrir:

Fast-forward merge (caso simple)

Si no hiciste ningún commit en main mientras trabajabas en tu rama, Git simplemente "avanza" main hasta donde está tu rama. Es la fusión más limpia y simple — no crea ningún commit extra.

# Git muestra algo como:
# Updating a1b2c3d..e4f5g6h
# Fast-forward
#  styles.css | 15 +++++++++++++++
#  1 file changed, 15 insertions(+)

Merge commit (cuando ambas ramas tienen commits nuevos)

Si mientras trabajabas en tu rama, alguien (o tú mismo) hizo commits en main, Git necesita crear un commit de merge que une las dos historias. Git abrirá tu editor para que confirmes el mensaje del merge commit.

# Git muestra algo como:
# Merge made by the 'ort' strategy.
#  styles.css | 15 +++++++++++++++
#  1 file changed, 15 insertions(+)

Limpiar: borrar la rama

Una vez que los cambios están en main, la rama ya no tiene utilidad. Bórrala para mantener tu repositorio limpio:

git branch -d feature/dark-mode

El -d (delete) solo funciona si la rama ya fue fusionada. Git te protege de borrar accidentalmente una rama con trabajo sin fusionar. Si realmente quieres borrar una rama sin fusionar, usa -D (mayúscula), pero piénsalo dos veces.

Convenciones para nombrar ramas

No pongas nombres como prueba1 o cambios. Usa un prefijo que indique el propósito de la rama:

Este formato se llama branch naming convention y es estándar en la industria. Cuando trabajes en equipo, todo el mundo sabrá qué hace cada rama con solo leer su nombre.

¿Cuándo usar ramas?

Siempre. En serio. Crea una rama para:

• Cada nueva funcionalidad — por pequeña que sea
• Cada corrección de error — así puedes probar el fix sin afectar nada
• Cada experimento — si no funciona, borras la rama y ya

El flujo es siempre el mismo: crear rama, trabajar, commit, volver a main, merge, borrar rama. Con la práctica lo harás en automático.

Resumen