02
Nivel 02 · Intermedio

Ramas y equipo

Ramas, fusiones y conflictos, y cómo trabajar con un repositorio remoto: fetch, pull, push y pull requests. Lo que necesitas para trabajar con otras personas sin miedo a romper nada.

Lección 2.1

Qué es una rama de verdad

En otros sistemas, crear una rama copia el proyecto entero. En Git, una rama es un nombre que apunta a un commit. Nada más. Por eso crear una rama es instantáneo, y por eso en Git se crean ramas para todo.

En simple

Los commits son la historia; las ramas son post-its pegados en algunos commits. Cuando haces commit, el post-it de la rama en la que estás se mueve al commit nuevo.

bash
git branch                    # lista las ramas; * marca la actual
git branch feature            # crea una rama (no te cambia a ella)
git switch -c feature         # crea y cambia en un solo paso
git branch -m viejo nuevo     # renombra
git branch -d feature         # borra (si ya está fusionada; -D fuerza)

Ahora pruébalo tú. Escribe los comandos en la terminal del laboratorio y mira cómo se mueven las etiquetas:

Lección 2.2

HEAD y cambiar de rama

HEAD es la respuesta de Git a «¿dónde estoy?». Normalmente apunta a una rama (HEAD → main), y esa rama apunta a un commit. Cuando cambias de rama, Git mueve HEAD y deja tus archivos como estaban en el commit de esa rama.

bash
git switch feature        # cambia a feature
git switch -              # vuelve a la rama anterior (como cd -)
git switch -c arreglo     # crea arreglo desde donde estás y cambia a ella
switch o checkoutgit checkout feature hace lo mismo y sigue existiendo: no está deprecado y no se va a eliminar. Desde Git 2.23, switch (cambiar de rama) y restore (restaurar archivos) separan sus dos trabajos, y los errores son más claros. Esta guía usa switch.
Si Git se niega a cambiar de ramaTienes cambios sin guardar en un archivo que es distinto en la otra rama, y cambiar los pisaría. Haz commit, guárdalos con git stash (lección 2.9) o descártalos. Los cambios que no chocan viajan contigo a la otra rama.
Lección 2.3

Fusionar: fast-forward

Terminaste tu trabajo en feature y quieres llevarlo a main. Te cambias a main y ejecutas git merge feature. Lo que pasa depende de la forma del grafo.

El caso más simple: nadie tocó main desde que creaste feature. Entonces no hay nada que combinar: Git solo adelanta la etiqueta main hasta el último commit de feature. Se llama fast-forward.

bash
git switch main
git merge feature            # fast-forward si se puede; si no, commit de merge
git merge --no-ff feature    # siempre crea un commit de merge (deja registro de la rama)
git merge --ff-only feature  # solo si es fast-forward; si no, falla sin tocar nada
En simple

Fast-forward = «main estaba atrás, ahora está adelante». No se crea ningún commit: solo se mueve una etiqueta.

Lección 2.4

Merge de tres vías

Ahora el caso real: mientras trabajabas en feature, alguien agregó commits a main. Las historias divergieron. Git busca el último commit que ambas ramas tienen en común (la base), mira qué cambió cada lado desde ahí y combina los dos conjuntos de cambios en un commit de merge, que tiene dos padres.

Se llama «de tres vías» porque compara tres versiones: la base, tu rama y la otra. Si un lado cambió un archivo y el otro no, gana el cambio. Si los dos cambiaron partes distintas del mismo archivo, Git junta ambas. Solo si los dos cambiaron las mismas líneas de forma distinta, te pregunta: eso es un conflicto (siguiente lección).

La estrategia ortDesde Git 2.34, el algoritmo de merge por defecto se llama ort. Por eso ves «Merge made by the 'ort' strategy». Es más rápido y maneja mejor los archivos renombrados que el anterior, recursive.
Lección 2.5

Conflictos sin pánico

Un conflicto no es un error: es Git diciendo «las dos ramas cambiaron lo mismo de forma distinta, y no me corresponde a mí decidir». Git deja el merge a medias, marca el archivo y espera a que elijas.

Leer los marcadores

precio.js durante el conflicto
<<<<<<< HEAD
const precio = 120;
=======
const precio = 95;
>>>>>>> feature

Arriba de ======= está tu versión (la de HEAD, la rama en la que estás); abajo, la que llega de la otra rama. Tu trabajo: dejar el archivo como debe quedar y borrar los tres marcadores. Practícalo:

Resuelve el conflicto

El flujo completo

bash
git merge feature          # CONFLICT (content): Merge conflict in precio.js
git status                 # "both modified: precio.js"
# edita el archivo, deja el resultado correcto y borra los marcadores
git add precio.js          # marca el archivo como resuelto
git commit                 # crea el commit de merge (el mensaje ya viene escrito)

git merge --abort          # o vuelve atrás como si nada hubiera pasado
Nuevo en Git 2.56: git add --resolvedAgrega al staging los archivos que tenían conflicto, sin arrastrar otros cambios sin relación, y antes revisa que no queden marcadores: si encuentra alguno, se detiene sin agregar nada. Útil cuando el merge toca muchos archivos.
Menos conflictos, más chicosIntegra seguido (ramas de días, no de semanas), haz commits chicos y no mezcles cambios de formato con cambios de lógica. Para ver también la versión base en los marcadores: git config --global merge.conflictStyle zdiff3.
Lección 2.6

Remotos: clone, origin y ramas remotas

Un remoto es otra copia del repositorio, normalmente en un servidor como GitHub. Cuando clonas, Git llama origin al remoto de donde viene, y crea dos cosas que conviene distinguir:

mainTu rama local. Se mueve cuando tú haces commit, merge o reset.
origin/mainUna rama remota: tu recuerdo de dónde estaba main en GitHub la última vez que preguntaste. Solo se mueve con fetch, pull o push.
UpstreamLa conexión entre las dos: main «sigue» a origin/main. Así Git sabe si vas adelante o atrás.
bash
git remote -v                   # remotos y sus URL
git branch -vv                  # cada rama con su upstream y si va adelante o atrás
git remote add origin git@github.com:ana/tienda.git   # conectar un repo creado con init
HTTPS o SSHCon HTTPS, GitHub pide un token (no tu contraseña) o un gestor de credenciales; Git for Windows y GitHub CLI (gh auth login) lo configuran solos. Con SSH generas una llave una vez (ssh-keygen -t ed25519), la agregas a tu cuenta y no vuelves a escribir nada.
Lección 2.7

fetch, pull y push

Git nunca habla con el servidor por su cuenta. Tres comandos mueven commits entre tu repositorio y el remoto:

ComandoQué hace¿Toca tus ramas?
git fetchDescarga commits nuevos y mueve origin/*No. Siempre seguro
git pullfetch y después integra origin/tu-rama en tu ramaSí: merge, rebase o fast-forward
git pushSube tus commits y mueve tu rama en el servidorMueve la del servidor
bash
git fetch                       # mira qué hay de nuevo sin tocar nada
git log main..origin/main       # qué commits llegaron
git pull                        # trae e integra
git push                        # sube
git push -u origin feature      # primera vez de una rama: crea y conecta el upstream
pull con historias distintasSi tú tienes commits locales y el servidor también, git pull tiene que combinarlos. Con pull.rebase true tus commits se reaplican encima (historia lineal); con false, se crea un commit de merge. Si no lo configuraste, Git te pide elegir. Lo configuraste en la lección 1.2.
Lección 2.8

Cuando push es rechazado

Tarde o temprano verás esto:

salida
 ! [rejected]        main -> main (fetch first)
error: failed to push some refs to 'github.com:ana/tienda.git'
hint: Updates were rejected because the remote contains work that you do not
hint: have locally.

No es un error tuyo: alguien subió commits que tú no tienes. Si Git aceptara tu push, su trabajo desaparecería del servidor. Por eso solo acepta pushes que avanzan la rama remota (fast-forward).

bash
git pull --rebase     # trae lo nuevo y pone tus commits encima
git push              # ahora sí es un avance
No fuerces en ramas compartidasgit push --force reemplaza la rama del servidor por la tuya, y borra lo que otros subieron. En tu propia rama, tras un rebase, a veces hace falta forzar: usa --force-with-lease (lección 3.9), que se niega si hay trabajo ajeno que no viste.
Lección 2.9

Guardar a medias: stash

Estás a mitad de algo y te piden un arreglo urgente en otra rama. No quieres hacer un commit de «wip» ni perder lo que llevas. git stash guarda tus cambios en una pila y deja el directorio de trabajo limpio.

bash
git stash push -m "búsqueda a medias"   # guarda y limpia
git stash -u                            # incluye archivos nuevos sin seguimiento
git stash list                          # stash@{0}, stash@{1}...
git stash pop                           # aplica el último y lo quita de la pila
git stash apply stash@{1}               # aplica uno y lo deja en la pila
git stash drop stash@{1}                # borra uno
Úsalo como bolsillo, no como cajónUn stash es fácil de olvidar: no tiene rama y su nombre es un número. Para algo que va a durar más de un rato, mejor una rama con un commit temporal, o un worktree (nivel Experto).
Lección 2.10

Tags y versiones

Un tag es como una rama que nunca se mueve: un nombre fijo para un commit. Se usa para marcar versiones publicadas: v1.0.0, v1.1.0. En los grafos de esta guía, los tags son las etiquetas blancas.

bash
git tag -a v1.2.0 -m "Versión 1.2.0"    # tag anotado: con autor, fecha y mensaje
git tag v1.2.0-beta                     # tag liviano: solo el nombre
git tag -l "v1.*"                       # lista
git push origin v1.2.0                  # los tags no suben con un push normal
git push --tags                         # sube todos
git switch --detach v1.2.0              # mira el código de esa versión

Usa tags anotados para versiones: guardan quién y cuándo, y se pueden firmar. La convención más común para los números es versionado semántico (MAYOR.MENOR.PARCHE): sube MAYOR si rompes compatibilidad, MENOR si agregas funciones, PARCHE si solo corriges.

Releases en GitHubUn «Release» de GitHub es un tag más notas y archivos descargables. Crea el tag con Git (o desde la interfaz) y GitHub arma la página.
Lección 2.11

El flujo con pull requests

Casi todos los equipos trabajan igual: nadie hace commit directo en main. Cada cambio vive en su rama, se sube, y se propone con un pull request (en GitLab, merge request), donde otras personas lo revisan y las pruebas automáticas lo validan antes de fusionarlo.

bash
git switch main && git pull          # parte desde main al día
git switch -c login-google           # una rama por cambio
# ... commits ...
git push -u origin login-google      # súbela y abre el pull request en GitHub
# ... revisión: más commits y git push actualizan el mismo PR ...
git switch main && git pull          # después del merge, trae main
git branch -d login-google           # y borra tu rama local
Botón de merge en GitHubResultado en main
Create a merge commitTodos tus commits más un commit de merge
Squash and mergeUn solo commit con todos tus cambios (el más común)
Rebase and mergeTus commits copiados encima de main, sin commit de merge
Con squash, borra tu rama despuésTras un «Squash and merge», tus commits originales no están en main (está su resumen). Si sigues trabajando en la misma rama, la próxima PR va a mostrar los cambios viejos otra vez. Rama nueva para cada cambio. Desde Git 2.56, git branch --delete-merged origin limpia las ramas locales ya fusionadas.
Quiz final

Quiz · Nivel Intermedio

Responde todas correctamente para aprobar