Ramas, fusión y conflictos

Una rama te permite probar una idea sin tocar la versión estable del proyecto. Cuando la idea funciona, la integras con git merge. Si las dos ramas cambiaron las mismas líneas, Git te pide que decidas: eso es un conflicto.

En esta lección aprenderás:

  1. Qué es una rama y qué es HEAD.
  2. A crear, listar, cambiar y borrar ramas con git branch y git switch.
  3. A ver el historial como un grafo con git log --oneline --graph --all.
  4. La diferencia entre una fusión fast-forward y un merge commit.
  5. A leer los marcadores de un conflicto, resolverlo o cancelar la fusión.

Todo ocurre en tu computadora: no hace falta ningún servidor.

Qué es una rama

Una rama es un puntero móvil a un commit. No es una copia de los archivos: es solo un nombre (por ejemplo main) que apunta al último commit de una línea de trabajo. Cada vez que haces un commit en esa rama, el puntero avanza al commit nuevo.

HEAD indica dónde estás. Normalmente apunta a una rama (HEAD -> main), y por eso tus commits nuevos hacen avanzar esa rama.

En la lección Deshacer cambios usaste git switch --detach <hash>: ahí HEAD apuntaba directamente a un commit, sin rama. Eso es detached HEAD. Con ramas, HEAD vuelve a apuntar a un nombre que avanza contigo.

Preparar el repositorio de práctica

Todos los ejemplos de esta lección siguen uno detrás de otro en el mismo repositorio. Créalo en una carpeta vacía:

mkdir proyecto
cd proyecto
git init

Crea saludo.txt con este contenido:

Hola mundo
git add saludo.txt
git commit -m "Agrega saludo inicial"
[main (root-commit) 954f1dd] Agrega saludo inicial
 1 file changed, 1 insertion(+)
 create mode 100644 saludo.txt

Los hashes de tu terminal serán distintos: cada commit tiene el suyo.

Ver, crear y cambiar de rama

Listar ramas

git branch
* main

El asterisco marca la rama actual, la que apunta HEAD.

Crear una rama y cambiarte a ella

git switch -c despedida
Switched to a new branch 'despedida'

git switch -c <nombre> crea la rama en el commit actual y te cambia a ella. Ahora git branch muestra:

* despedida
  main

Si la rama ya existe, te cambias a ella sin -c:

git switch main

Al cambiar de rama, Git reemplaza los archivos de tu carpeta por los del commit al que apunta la nueva rama. Antes de cambiar, confirma tus cambios con un commit: si tienes cambios sin confirmar que chocan con la otra rama, Git se niega a cambiar para no perderlos.

Ver el historial como un grafo

git log --oneline muestra solo la rama actual. Para ver todas las ramas y cómo se separan y se juntan:

git log --oneline --graph --all
  • --graph dibuja las líneas de cada rama a la izquierda.
  • --all incluye todas las ramas, no solo la actual.
  • Entre paréntesis aparece a qué commit apunta cada rama y HEAD.

Lo usarás después de cada paso de esta lección.

Fusión fast-forward

Sigue en la rama despedida (vuelve con git switch despedida si cambiaste a main). Crea despedida.txt:

Hasta luego
git add despedida.txt
git commit -m "Agrega despedida"
git switch main

En main el archivo despedida.txt no existe: esa rama todavía apunta al commit anterior. El grafo lo muestra:

git log --oneline --graph --all
* 54f85d4 (despedida) Agrega despedida
* 954f1dd (HEAD -> main) Agrega saludo inicial

main no se movió desde que creaste despedida. Para integrar, te paras en la rama que recibe los cambios y fusionas la otra:

git merge despedida
Updating 954f1dd..54f85d4
Fast-forward
 despedida.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 despedida.txt

Como main no tenía commits propios, Git no necesita combinar nada: solo adelanta el puntero main hasta el commit de despedida. Eso es un fast-forward, y no crea ningún commit nuevo.

* 54f85d4 (HEAD -> main, despedida) Agrega despedida
* 954f1dd Agrega saludo inicial
Fusión fast-forward: main avanza hasta el commit de la rama despedida

Antes de git merge A B HEAD -> main despedida

Después de git merge despedida A B main avanza HEAD -> main, despedida Sin commit nuevo: solo se mueve el puntero

Fast-forward: A es «Agrega saludo inicial» y B es «Agrega despedida». Como main no avanzó, git merge despedida solo mueve el puntero main de A a B.

Fusión con merge commit

Ahora haz que las dos ramas avancen, cada una en un archivo distinto. Crea la rama autor y agrega autor.txt:

git switch -c autor
Autor: Ana
git add autor.txt
git commit -m "Agrega autor"
git switch main

En main, cambia despedida.txt para que diga:

Hasta luego, nos vemos pronto
git add despedida.txt
git commit -m "Mejora la despedida"
git log --oneline --graph --all
* 2cf59a0 (autor) Agrega autor
| * 5d789cf (HEAD -> main) Mejora la despedida
|/
* 54f85d4 Agrega despedida
* 954f1dd Agrega saludo inicial

Las ramas divergieron: cada una tiene un commit que la otra no tiene. Ya no alcanza con mover un puntero. Fusiona:

git merge autor

Git abre tu editor con el mensaje Merge branch 'autor'. Acéptalo: guarda y cierra el editor. Git responde:

Merge made by the 'ort' strategy.
 autor.txt | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 autor.txt

Git compara las dos puntas con su ancestro común (54f85d4), combina los cambios y crea un merge commit: un commit con dos padres. Por eso se llama fusión de tres vías.

*   0a2af46 (HEAD -> main) Merge branch 'autor'
|\
| * 2cf59a0 (autor) Agrega autor
* | 5d789cf Mejora la despedida
|/
* 54f85d4 Agrega despedida
* 954f1dd Agrega saludo inicial
Fusión de tres vías: main y autor divergen desde B y se unen en el merge commit M main autor A B Ancestro común C Cambia despedida.txt D Crea autor.txt M Merge commit (dos padres)
Merge commit: A «Agrega saludo inicial», B «Agrega despedida», C «Mejora la despedida» en main y D «Agrega autor» en autor. Las dos ramas avanzaron en archivos distintos, así que git merge autor crea M sin conflictos.

Borrar una rama fusionada

Cuando una rama ya está integrada, su nombre sobra: los commits siguen en main.

git branch -d despedida
git branch -d autor
Deleted branch despedida (was 54f85d4).
Deleted branch autor (was 2cf59a0).

git branch -d se niega a borrar una rama que tiene commits sin fusionar:

error: the branch 'prueba' is not fully merged

Git te sugiere git branch -D para forzarlo. Úsalo solo si de verdad quieres descartar esos commits.

Conflictos

Cuándo hay un conflicto

Git combina solo los cambios que no se pisan: archivos distintos, o partes distintas del mismo archivo. Hay conflicto cuando las dos ramas cambiaron las mismas líneas de forma diferente desde el ancestro común. Git no adivina cuál versión es la buena: detiene la fusión y te pregunta.

Provocar un conflicto

Sigue en el mismo repositorio, en main. Ahora saludo.txt dice Hola mundo. Crea una rama nueva y cambia esa línea:

git switch -c saludo-formal

Edita saludo.txt para que diga:

Buenos días, mundo
git add saludo.txt
git commit -m "Usa un saludo formal"
git switch main

En main, saludo.txt vuelve a decir Hola mundo. Cambia la misma línea de otra forma:

Hola, mundo entero
git add saludo.txt
git commit -m "Amplía el saludo"
git merge saludo-formal
Auto-merging saludo.txt
CONFLICT (content): Merge conflict in saludo.txt
Automatic merge failed; fix conflicts and then commit the result.

La fusión quedó a medias. git status te dice qué archivos esperan una decisión:

On branch main
You have unmerged paths.
  (fix conflicts and run "git commit")
  (use "git merge --abort" to abort the merge)

Unmerged paths:
  (use "git add <file>..." to mark resolution)
	both modified:   saludo.txt

Leer los marcadores

Abre saludo.txt:

<<<<<<< HEAD
Hola, mundo entero
=======
Buenos días, mundo
>>>>>>> saludo-formal
  • <<<<<<< HEAD abre la versión de tu rama actual (main).
  • ======= separa las dos versiones.
  • >>>>>>> saludo-formal cierra la versión de la rama que estás fusionando.
Marcadores de conflicto en saludo.txt: versión de main, separador y versión de saludo-formal <<<<<<< HEAD Hola, mundo entero ======= Buenos días, mundo >>>>>>> saludo-formal Tu rama actual (main) Separador La rama que fusionas
Las dos ramas cambiaron la misma línea de saludo.txt desde el ancestro común, así que Git escribe ambas versiones entre marcadores y espera tu decisión.

Cancelar la fusión: git merge --abort

Si no quieres resolverlo ahora, vuelve al estado anterior a git merge:

git merge --abort
git status
On branch main
nothing to commit, working tree clean

saludo.txt vuelve a decir Hola, mundo entero. Para seguir con el ejemplo, intenta la fusión otra vez:

git merge saludo-formal

Obtienes el mismo CONFLICT (content) de antes.

Resolver el conflicto

  1. Decide el contenido final. Puede ser una versión, la otra o una combinación.
  2. Borra las tres líneas de marcadores (<<<<<<<, =======, >>>>>>>).
  3. Guarda el archivo.

En este ejemplo combinamos las dos ideas. saludo.txt queda así:

Buenos días, mundo entero

Marca el archivo como resuelto con git add:

git add saludo.txt
git status
On branch main
All conflicts fixed but you are still merging.
  (use "git commit" to conclude merge)

Cerrar la fusión

git commit

Git abre el editor con el mensaje Merge branch 'saludo-formal'. Acéptalo: guarda y cierra.

[main 6b5dba7] Merge branch 'saludo-formal'

git merge --continue hace lo mismo que git commit en este punto: también abre el editor con el mensaje por defecto. Usa el que prefieras.

git log --oneline --graph --all
git branch -d saludo-formal
*   6b5dba7 (HEAD -> main) Merge branch 'saludo-formal'
|\
| * 54ee0a7 (saludo-formal) Usa un saludo formal
* | 022bf8c Amplía el saludo
|/
*   0a2af46 Merge branch 'autor'
...

Qué puede recuperar Git y qué no

  • Lo que ya está en un commit casi siempre se puede recuperar. Aunque borres una rama o te equivoques al fusionar, los commits siguen existiendo un tiempo y git reflog te muestra sus hashes (lo viste en Deshacer cambios).
  • Lo que nunca confirmaste no se puede recuperar. git restore y git reset --hard descartan cambios sin commit, y Git no guarda copia de ellos.

Por eso: haz commit antes de cambiar de rama o de fusionar.

Consejos

  • Crea una rama por cada idea o tarea, con un nombre que la describa.
  • Haz commits pequeños: los conflictos son más cortos y fáciles de leer.
  • Fusiona seguido: cuanto más divergen dos ramas, más conflictos acumulan.
  • Lee el conflicto completo antes de editar, y revisa el resultado con git diff --staged antes del commit.
  • Errores comunes: hacer commit con marcadores todavía en el archivo, o borrar el archivo entero en lugar de las líneas en conflicto.

Resumen

Quiero…Comando
Ver las ramasgit branch
Crear una rama y cambiarme a ellagit switch -c <rama>
Cambiar a una rama existentegit switch <rama>
Ver todas las ramas como grafogit log --oneline --graph --all
Integrar otra rama en la actualgit merge <rama>
Marcar un conflicto como resueltogit add <archivo>
Cerrar la fusióngit commit o git merge --continue
Cancelar una fusión con conflictosgit merge --abort
Borrar una rama ya fusionadagit branch -d <rama>

Ejercicios prácticos

Ejercicio 1: una fusión fast-forward

En un repositorio nuevo con un commit en main, crea la rama contacto, agrega contacto.txt en un commit y fusiónala en main. Comprueba que Git responde Fast-forward y borra la rama.

Ver solución
git switch -c contacto
# Crea contacto.txt con cualquier texto
git add contacto.txt
git commit -m "Agrega contacto"
git switch main
git merge contacto
git log --oneline --graph --all
git branch -d contacto

git merge muestra Fast-forward porque main no tenía commits nuevos: solo avanzó el puntero.

Ejercicio 2: un merge commit sin conflictos

Crea la rama colores y agrega colores.txt en un commit. Vuelve a main y, antes de fusionar, haz un commit que cambie otro archivo. Fusiona colores y mira el grafo.

Ver solución
git switch -c colores
# Crea colores.txt
git add colores.txt
git commit -m "Agrega colores"
git switch main
# Cambia saludo.txt
git add saludo.txt
git commit -m "Actualiza el saludo"
git merge colores
# Acepta el mensaje "Merge branch 'colores'" en el editor
git log --oneline --graph --all

Git responde Merge made by the 'ort' strategy. y el grafo muestra un commit con dos líneas que llegan a él: el merge commit.

Ejercicio 3: cancelar y resolver un conflicto

Crea la rama titulo y cambia la primera línea de saludo.txt. En main, cambia esa misma línea de otra forma. Fusiona, cancela con git merge --abort, vuelve a fusionar y esta vez resuelve el conflicto cerrando con git merge --continue.

Ver solución
git switch -c titulo
# Cambia la primera línea de saludo.txt
git add saludo.txt
git commit -m "Cambia el saludo en titulo"
git switch main
# Cambia la misma línea con otro texto
git add saludo.txt
git commit -m "Cambia el saludo en main"
git merge titulo
# CONFLICT (content): Merge conflict in saludo.txt
git merge --abort
git status
# nothing to commit, working tree clean
git merge titulo
# Deja el contenido final y borra los marcadores
git add saludo.txt
git merge --continue
git branch -d titulo

Ejercicio 4: una rama sin fusionar

Crea la rama borrador, haz un commit en ella, vuelve a main e intenta borrarla con git branch -d. ¿Qué responde Git y por qué? ¿Cómo la borrarías sin perder ese commit?

Ver solución

Git responde error: the branch 'borrador' is not fully merged, porque el commit de borrador no está en main: si borras la rama, ningún nombre apunta a ese commit. Para conservarlo, primero fusiona y después borra:

git merge borrador
git branch -d borrador

Si de verdad quieres descartar el trabajo, git branch -D borrador la borra igual.