03
Nivel 03 · Avanzado

Reescribir y rescatar

Rebase, rebase interactivo, cherry-pick, reset y revert para dar forma a la historia, y reflog, bisect y force push seguro para salir de cualquier lío. Aquí se pierde el miedo a Git.

Lección 3.1

Rebase: mover commits a otra base

Tu rama feature salió de main hace unos días, y main avanzó. Con merge juntarías las dos historias. Con rebase haces otra cosa: tomas tus commits y los vuelves a aplicar, uno por uno, encima del main actual, como si hubieras empezado tu rama hoy.

El detalle clave: los commits de un rebase son copias nuevas. Tienen el mismo cambio y el mismo mensaje, pero otro padre, y por lo tanto otro hash. Los originales no se borran: quedan sin rama que los apunte, y el reflog los recuerda.

bash
git switch feature
git rebase main             # reaplica tus commits encima de main
# si hay conflicto: resuélvelo, git add, y luego
git rebase --continue       # sigue con el próximo commit
git rebase --abort          # o vuelve a como estaba todo antes
La regla de oroNo hagas rebase de commits que otras personas ya tienen. Si alguien basó trabajo en tus commits originales y tú los reemplazas por copias, sus historias y la tuya ya no coinciden. Rebase sí, pero en tu rama, antes de compartirla (o en una rama solo tuya).
Lección 3.2

¿Merge o rebase?

Las dos integran cambios; la diferencia es cómo queda la historia. Merge conserva lo que pasó de verdad (dos líneas que se unen). Rebase cuenta una historia más simple (una sola línea), a costa de reescribir tus commits.

MergeRebase
HistoriaReal, con bifurcacionesLineal, más fácil de leer
HashesNo cambianTus commits cambian de hash
ConflictosSe resuelven una vezPueden aparecer en cada commit reaplicado
Seguro en ramas compartidasSíNo
Una regla que funciona

Usa rebase para actualizar tu rama con lo último de main antes de abrir o actualizar tu pull request. Usa merge (o squash) para integrar la rama terminada en main. Así tu rama se lee limpia y main nunca se reescribe.

Lección 3.3

Rebase interactivo: limpiar antes de compartir

Mientras trabajas, haces commits como «wip», «arregla typo» o «ahora sí». Está bien: son tu borrador. Antes de pedir revisión, el rebase interactivo te deja editar esa serie: unir commits, cambiar mensajes, reordenarlos o borrarlos.

bash
git rebase -i main          # edita todos los commits de tu rama que no están en main
git rebase -i HEAD~4        # o los últimos cuatro
PalabraQué hace con ese commit
pick (p)Lo deja tal cual
reword (r)Lo deja, pero te deja cambiar el mensaje
edit (e)Se detiene ahí para que cambies el contenido (luego git rebase --continue)
squash (s)Lo une al commit de arriba y te deja combinar los mensajes
fixup (f)Lo une al de arriba y descarta su mensaje
drop (d)Lo elimina

En el editor, el commit más viejo va arriba (al revés que en git log). Para reordenar, mueve las líneas.

Correcciones que se acomodan solas

bash
git commit --fixup=a1b2c3d          # "fixup! ..." : corrige un commit anterior
git rebase -i --autosquash main     # coloca y marca los fixup automáticamente
git config --global rebase.autoSquash true   # siempre

Nuevo: git history (experimental)

Git 2.54 agregó git history para las ediciones más comunes sin abrir un rebase interactivo. Git 2.55 sumó fixup y 2.56, drop. Por diseño, aborta si la operación generaría un conflicto, y todavía no funciona con historias que tienen merges.

bash
git history reword a1b2c3d     # cambia el mensaje de ese commit
git history split a1b2c3d      # divide un commit en dos, eligiendo trozos
git history fixup a1b2c3d      # mete lo que está en staging dentro de ese commit
git history drop a1b2c3d       # lo elimina y reaplica los que venían después
Lección 3.4

Cherry-pick: copiar un commit

A veces no quieres una rama entera, solo un commit. El caso típico: arreglaste un bug en main y necesitas el mismo arreglo en release/1.0, sin traer todo lo nuevo. git cherry-pick copia ese cambio y lo aplica encima de tu rama actual.

bash
git switch release/1.0
git cherry-pick -x a1b2c3d      # -x anota de qué commit viene la copia
git cherry-pick A^..B           # una serie de commits (de A a B, incluidos)
git cherry-pick --abort         # si hay conflicto y prefieres no seguir
No lo uses para todoCada cherry-pick crea un commit duplicado (mismo cambio, otro hash). Si después fusionas las dos ramas, Git normalmente lo nota, pero la historia queda confusa. Para traer muchos commits, merge o rebase.
Lección 3.5

Reset: soft, mixed y hard

git reset asusta porque hace tres cosas distintas según la opción. Todo se aclara con las tres áreas de la lección 1.4: reset mueve la rama actual a otro commit, y luego, según el modo, iguala también el staging y el directorio de trabajo.

ModoRamaStagingDirectorio de trabajo
--softSe mueveIgualIgual
--mixed (por defecto)Se mueveSe iguala al commitIgual
--hardSe mueveSe iguala al commitSe iguala al commit: lo no guardado se pierde
bash
git reset --soft HEAD~1      # deshace el commit; los cambios quedan listos en staging
git reset HEAD~1             # deshace el commit; los cambios quedan sin agregar
git reset --hard HEAD~1      # deshace el commit y sus cambios
git reset --hard origin/main # deja tu main idéntico al del servidor
--hard borra de verdad lo que no estaba guardadoLos commits que «deshaces» se recuperan con el reflog. Pero los cambios que no estaban en ningún commit ni en el staging desaparecen sin rastro. Antes de un --hard, un git status.
Lección 3.6

Revert: deshacer sin reescribir

Si el commit que quieres deshacer ya está en una rama compartida, no lo borres: contrarréstalo. git revert crea un commit nuevo que aplica el cambio inverso. La historia no se reescribe, nadie tiene que hacer nada especial y se sube con un push normal.

bash
git revert a1b2c3d          # abre el editor con 'Revert "..."'
git revert --no-edit HEAD   # sin abrir el editor
git revert -m 1 <merge>     # revertir un merge: -m 1 dice qué padre es "la línea principal"
Reset o revert

¿El commit está solo en tu máquina? Reset (o rebase). ¿Ya lo tiene alguien más? Revert.

Lección 3.7

Reflog: la red de seguridad

Casi nada se pierde en Git. Cada vez que HEAD o una rama se mueve (commit, reset, rebase, switch, merge), Git lo anota en el reflog. Si «perdiste» commits con un reset o un rebase, el reflog sabe dónde estaban.

bash
git reflog                       # HEAD@{0} es ahora, HEAD@{1} el paso anterior...
git reflog show feature          # el de una rama
git reset --hard HEAD@{1}        # vuelve a donde estabas antes del último movimiento
git branch rescate HEAD@{4}      # o crea una rama en ese punto, sin tocar nada más
git log -g --oneline main@{yesterday}..main   # qué cambió en main desde ayer
Lo que el reflog sí guardaLo que no
Commits a los que apuntó HEAD o una rama, durante 90 días (30 si quedaron inalcanzables)Cambios que nunca entraron en un commit ni en el staging
Solo en tu máquinaNo viaja con push: el reflog de un compañero no te sirve a ti
Lección 3.8

HEAD separado (detached)

Si te cambias a un commit o a un tag en vez de a una rama, HEAD apunta directo a ese commit. Git dice «You are in 'detached HEAD' state». No es un error: es el modo para mirar una versión vieja o probar algo. El único riesgo es hacer commits ahí y luego irte.

bash
git switch --detach v1.2.0     # mira el código de esa versión
git switch -c experimento      # ¿hiciste commits que quieres guardar? crea una rama aquí
git switch -                   # vuelve a tu rama
Si ya te fuisteGit te avisó: «Warning: you are leaving 2 commits behind» e imprimió el hash. Créale una rama: git branch experimento a1b2c3d. ¿No lo copiaste? Está en git reflog.
Lección 3.9

Push forzado sin pisar a nadie

Después de un rebase o un amend en tu rama, el servidor tiene la versión vieja y tu push normal es rechazado (no es un avance). Tienes que forzarlo. La pregunta es cómo.

bash
git push --force-with-lease                     # fuerza solo si nadie subió algo nuevo
git push --force-with-lease --force-if-includes # además exige que hayas integrado lo que viste
git config --global alias.pushf "push --force-with-lease --force-if-includes"

--force-with-lease compara la rama del servidor con tu origin/feature: si coinciden, nadie subió nada desde tu último fetch y es seguro reemplazarla. Si no, se niega. El problema: un git fetch en segundo plano (tu editor lo hace) actualiza origin/feature sin que veas los commits nuevos. --force-if-includes cierra ese hueco.

Protege main en el servidorEn GitHub y GitLab activa la protección de ramas (o rulesets) en main: prohíbe force push y exige pull request. Así un error local nunca reescribe la rama de todos.
Lección 3.10

Bisect: encontrar el commit culpable

Algo funcionaba hace dos semanas y hoy no, y entre medio hay 200 commits. git bisect hace una búsqueda binaria: te lleva al commit del medio, le dices si está bien o mal, y descarta la mitad. Con 200 commits, encuentra al culpable en unos 8 pasos.

bash
git bisect start
git bisect bad                 # el commit actual está mal
git bisect good v2.3           # esta versión funcionaba
# Git te cambia a un commit intermedio: pruébalo y responde
git bisect good                # o: git bisect bad · git bisect skip si no se puede probar
# ... hasta: "a1b2c3d is the first 'bad' commit"
git bisect reset               # vuelve a donde estabas

git bisect run npm test        # o automatízalo con cualquier comando

Con bisect run, el código de salida decide: 0 es bueno, de 1 a 127 es malo (salvo 125, que significa «no se puede probar, sáltalo»). Un script de diez líneas que reproduce el bug encuentra el culpable mientras tomas un café.

Lección 3.11

Investigar el código con Git

Git sabe mucho más que «qué cambió». Bien preguntado, te dice quién escribió cada línea, cuándo apareció una función o por qué existe un if raro.

bash
git blame -L 40,60 src/carrito.js    # quién cambió cada línea, y en qué commit
git blame -w -C src/carrito.js       # ignora espacios y sigue código movido entre archivos
git log -S "calcularIVA" --oneline   # commits que agregaron o quitaron ese texto
git log -G "descuento\s*=" -p        # commits cuyo diff coincide con una regex
git log -L :calcularIVA:src/iva.js   # la historia de una función
git grep -n "TODO" main              # busca en los archivos de una rama
git range-diff main feature@{1} feature   # cómo cambió tu serie antes y después del rebase
Que blame ignore los commits de formatoSi tu equipo hizo un commit gigante de formato, todo blame apunta a él. Pon sus hashes en un archivo .git-blame-ignore-revs y configura git config blame.ignoreRevsFile .git-blame-ignore-revs. GitHub lo respeta automáticamente.
Quiz final

Quiz · Nivel Avanzado

Responde todas correctamente para aprobar