Todos los artículos

Infra15 min de lectura

Git sin complicaciones: stash, amend, fetch, rebase y reflog

Git sin miedo: git stash, git mv, commit --amend, fetch vs pull, rebase vs merge, rebase interactivo, push --force-with-lease y el reflog para deshacer casi todo.

También en Português, English, Français

¿Te da miedo usar Git? ¿Lo máximo que haces es git add, git commit y git push, y el resto de los comandos te asusta? No eres la única persona.

Git parece intimidante porque casi cada comando toca un lugar distinto, y nadie te muestra el mapa. Cuando entiendes dónde actúa cada comando, deja de ser un monstruo y se vuelve una herramienta que te salva cada semana.

Publiqué la primera versión de este post en Medium en 2023, en portugués. Esta es la versión revisada: mejores explicaciones, algunos errores míos corregidos y cada comando probado de nuevo.

Aquí explico los comandos que más uso además de commit y push, con ejemplos que ejecuté de verdad en un repositorio de prueba: git stash, git mv, git commit --amend, git fetch, git rebase (y el interactivo) y, al final, git reflog, que deshace casi cualquier error.

TL;DR#

  • git stash guarda en un cajón los cambios que aún no hiciste commit, y git stash pop los devuelve. Los archivos nuevos solo entran con -u.
  • git mv es un atajo de mv + git add. Git no guarda renombres: los deduce por el contenido. Para ver el historial de un archivo renombrado, usa git log --follow.
  • git commit --amend cambia el último commit por uno nuevo. Ideal para un archivo olvidado o un mensaje equivocado, siempre que el commit aún no se haya subido.
  • git fetch solo descarga y actualiza origin/main. No toca tu código. git pull es fetch + merge (o rebase).
  • git rebase vuelve a aplicar tus commits sobre otra base y deja el historial en línea recta. El interactivo (-i) junta, edita y reordena commits.
  • ¿Reescribiste historial que ya estaba subido? Usa git push --force-with-lease, nunca --force (ni +branch). En mi prueba, +main borró el commit de una compañera sin avisar.
  • ¿Algo salió mal? git reflog lista todo por donde pasó tu HEAD, y git reset --hard HEAD@{n} te devuelve ahí.

El mapa: dónde actúa cada comando#

Antes de los comandos, el dibujo que me hizo entender Git. Hay cinco lugares, y cada comando lleva cambios de uno a otro:

  1. Directorio de trabajo: los archivos que editas.
  2. Stash: un cajón para guardar cambios sin hacer commit.
  3. Index (o staging): lo que va a entrar en el próximo commit, después de git add.
  4. Repositorio local: tus commits, en tu máquina.
  5. Remoto: GitHub (o GitLab, Bitbucket). Tu máquina guarda una copia de lo último que vio allí, origin/main.
Cada comando lleva cambios de un lugar a otro. El fetch se detiene en origin/main

Guarda este mapa. Casi toda confusión con Git viene de creer que un comando actúa en un lugar cuando actúa en otro.

git stash: el cajón#

Estás en medio de una tarea, con archivos modificados, y necesitas cambiar de branch para corregir un bug urgente. Hacer commit del trabajo a medias queda feo. git stash guarda los cambios en un cajón y deja el directorio limpio:

git stash push -m "wip: signup form"
git switch hotfix/login
# ...fix the bug, commit, push...
git switch feature/signup
git stash pop

Un detalle que atrapa a mucha gente: un archivo nuevo, que Git todavía no rastrea, no va al cajón. En mi prueba, después de git stash, el archivo nuevo seguía ahí:

$ git stash push -m "wip: signup form"
Saved working directory and index state On main: wip: signup form
$ git status --short
?? draft.txt

Para llevar los archivos nuevos también, usa -u (de --include-untracked):

git stash push -u -m "wip: signup form"

El git stash save "nombre" que aparece en tutoriales viejos está obsoleto. La forma actual de ponerle nombre es git stash push -m "nombre".

¿pop o apply?#

Los dos devuelven los cambios del cajón al directorio de trabajo. La diferencia es qué pasa con el cajón:

  • git stash apply aplica y mantiene el stash en la lista. Útil para aplicar el mismo cambio en más de una branch.
  • git stash pop aplica y borra el stash de la lista. Es apply seguido de git stash drop.

Con una excepción: si el pop da conflicto, no borra nada. Git mismo te avisa:

Auto-merging app.txt
CONFLICT (content): Merge conflict in app.txt
...
The stash entry is kept in case you need it again.

Resuelves el conflicto y después borras el stash con git stash drop cuando tengas la certeza de que ya no lo necesitas.

Otros comandos del cajón:

git stash list              # every stash, newest first: stash@{0}, stash@{1}...
git stash show -p stash@{1} # what is inside one of them
git stash pop stash@{1}     # bring back a specific one
git stash drop stash@{1}    # delete one

git mv: renombrar y mover#

git mv renombra o mueve un archivo y deja el cambio listo para el commit:

git mv index.html home.html     # rename
git mv index.html public/       # move
git mv scripts src/scripts      # folders too

La primera versión de este post decía que git mv existe para "no perder el historial". Yo también lo creía, y no es exactamente así. Git no guarda renombres. Guarda el contenido de los archivos en cada commit y, a la hora de mostrarlo, compara: si un archivo desapareció y apareció otro casi igual, concluye que fue renombrado.

Por eso, mv + git add -A da exactamente el mismo resultado. Probé los dos, y git status muestra lo mismo:

$ git mv index.html home.html
$ git status --short
R  index.html -> home.html
 
$ mv home.html start.html && git add -A
$ git status --short
R  home.html -> start.html

La R es Git diciendo "detecté un renombre". git mv solo te ahorra un paso.

¿Y el historial? El git log de un archivo se detiene en el renombre. Para seguir el archivo por sus nombres anteriores, usa --follow:

$ git log --oneline -- home.html
3b727de rename index to home
 
$ git log --oneline --follow -- home.html
3b727de rename index to home
a366c0e add index page

Consejo: renombra en un commit y cambia el contenido en otro. Si renombras y reescribes la mitad del archivo en el mismo commit, Git puede no reconocer que es el mismo archivo, y ahí ni --follow encuentra el historial.

¿Cambiaste de idea antes del commit? Solo renómbralo de vuelta con git mv home.html index.html.

git commit --amend: arreglar el último commit#

"git amend" no existe como comando. Lo que existe es la opción --amend de git commit, que cambia el último commit por uno nuevo.

Olvidaste un archivo:

git add forgotten-file.ts
git commit --amend --no-edit   # same message, new content

Te equivocaste en el mensaje:

git commit --amend -m "feat: rename the home page"

Lo que poca gente nota es que el commit no se edita, se reemplaza. Fíjate en el hash cambiando con cada --amend en mi prueba:

22b393b rename again                  # before
f5024f2 rename again                  # after --amend --no-edit
4c2a0e4 feat: rename the home page    # after --amend -m

De ahí la regla: usa --amend solo en commits que aún no subiste. Si ya está en el remoto y alguien lo descargó, vas a necesitar un push forzado (más sobre eso al final) y esa persona va a quedarse con un commit que ya no existe.

git fetch: mirar antes de traer#

git fetch descarga lo nuevo del remoto y actualiza origin/main, esa copia del remoto que vive en tu máquina. No toca tu branch ni tus archivos. Es como leer los titulares sin abrir el periódico.

$ git fetch origin
From ../origin
   4c2a0e4..8d7de9d  main       -> origin/main
 
$ git status -sb
## main...origin/main [behind 1]
 
$ git log --oneline main..origin/main
8d7de9d feat: add the profile page

main..origin/main lista los commits que están en el remoto y todavía no están en tu main. Ves lo que llegó antes de decidir traerlo.

El fetch solo actualiza origin/main. El pull hace el fetch y lo junta en tu branch

¿Y git pull? Es fetch seguido de un merge (o de un rebase, si lo configuras). Descarga y junta en tu branch, todo de una vez:

git pull               # fetch + merge
git pull --rebase      # fetch + rebase

Prefiero hacer fetch antes cuando la branch es compartida o cuando pasé días sin actualizar. Así veo el tamaño del cambio antes de que el conflicto me estalle en la cara.

Traer cambios de otro repositorio#

fetch también funciona con cualquier remoto, no solo origin. Ejemplo: tienes un fork y quieres las novedades del proyecto original. Agrégalo como un segundo remoto:

git remote add upstream https://github.com/original-author/project.git
git fetch upstream
git merge upstream/main

upstream es solo un apodo, como origin. Después resuelves los conflictos (si los hay), haces commit y push a tu fork.

git rebase: volver a aplicar los commits sobre otra base#

Creaste una branch, hiciste dos commits, y mientras tanto alguien subió un commit nuevo a main. Para traer lo que entró en main, hay dos caminos:

  • git merge crea un commit de merge que une las dos historias. No se reescribe nada.
  • git rebase toma tus commits y los vuelve a aplicar uno por uno sobre la main nueva, como si hubieras empezado la branch ahora. El historial queda en línea recta.
El merge une las dos historias. El rebase vuelve a aplicar tus commits, con hashes nuevos

En mi prueba, mi main local tenía dos commits que origin/main no tenía, y origin/main tenía uno que yo no tenía:

* 0df7909 wip
* 6f1f89e add z
| * 8d7de9d feat: add the profile page   (origin/main)
|/
* 4c2a0e4 feat: rename the home page

Después de git rebase origin/main:

* 2b2bea3 wip
* 4f1c163 add z
* 8d7de9d feat: add the profile page
* 4c2a0e4 feat: rename the home page

Mis dos commits subieron, en línea recta, con hashes nuevos (0df7909 se volvió 2b2bea3). Ese es el punto clave del rebase: no mueve commits, crea commits nuevos con el mismo contenido.

¿Cuál usar? Ninguno es mejor, y muchos equipos eligen uno por defecto. La regla que importa es una sola: no hagas rebase de commits que otras personas ya descargaron. En tu branch, antes de abrir el PR, adelante.

Rebase interactivo: ordenar los commits antes del PR#

git rebase -i abre una lista con los commits y te deja decir qué hacer con cada uno:

git rebase -i HEAD~3   # the last 3 commits
pick 4f1c163 # add z
pick 2b2bea3 # wip
pick 060be7b # fix typo
 
# Rebase 8d7de9d..060be7b onto 8d7de9d (3 commands)

Debajo de esa lista, Git mismo explica los comandos. Los que más uso:

  • pick: mantiene el commit como está.
  • reword: lo mantiene, pero abre el editor para cambiar el mensaje.
  • edit: se detiene en ese commit para que cambies lo que quieras (archivos, autor) y después git rebase --continue.
  • squash: lo junta con el commit de arriba y combina los mensajes.
  • fixup: lo junta con el commit de arriba y descarta el mensaje de este.
  • drop: borra el commit.

Cambias la palabra al inicio de cada línea, guardas y cierras. Para juntar wip y fix typo en el commit de arriba, por ejemplo:

pick 4f1c163 # add z
fixup 2b2bea3 # wip
fixup 060be7b # fix typo

Para editar varios mensajes, cambia pick por reword. Git se va deteniendo en cada uno y abre el editor.

Si el editor no abre (o abre Vim y no sabes salir), configura VS Code:

git config --global core.editor "code --wait"

El --wait hace que Git espere a que cierres la pestaña antes de seguir.

Commits con el nombre o el e-mail equivocado#

Un clásico de computadora nueva: olvidaste configurar user.name y user.email, y los commits salieron como root@localhost. Primero, configúralos:

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Después, para corregir solo el último commit:

git commit --amend --no-edit --reset-author

Para corregir varios, en lugar de marcar edit uno por uno como yo hacía, usa --exec, que ejecuta un comando después de cada commit reaplicado:

git rebase origin/main --exec "git commit --amend --no-edit --reset-author"

Fíjate en origin/main en lugar de HEAD~10. Toma solo los commits que todavía no están en el remoto, o sea, solo los tuyos. En mi prueba, usé HEAD~2 y uno de los dos era el commit de una compañera, que ya estaba en el remoto. El rebase cambió su autor por el mío sin preguntar. Contar commits con HEAD~n es fácil de errar. Usar la base correcta, no.

Push forzado sin borrar el trabajo de los demás#

Todo comando que reescribe historial (--amend, rebase) crea commits nuevos. Si los viejos ya estaban en el remoto, el git push normal es rechazado, porque el remoto tendría que tirar commits. Ahí entra el push forzado.

La primera versión de este post sugería git push origin +nombre-de-la-branch. El + hace lo mismo que --force: sobrescribe el remoto con tu versión, sin mirar lo que hay allí. Hice la prueba: una compañera subió un commit a la branch mientras yo reescribía la mía. Con +main, el push pasó, y su commit desapareció del remoto:

$ git push origin +main
 + c0a4ca7...db2256b main -> main (forced update)

Con --force-with-lease, el mismo push fue rechazado:

$ git push --force-with-lease origin main
 ! [rejected]        main -> main (stale info)
error: failed to push some refs to '../origin.git'
El --force-with-lease solo sobrescribe si el remoto sigue como lo viste

--force-with-lease solo sobrescribe si el remoto sigue igual a la última versión que viste (tu origin/main). Si alguien subió algo mientras tanto, rechaza, y tú haces git fetch, traes el commit de esa persona e intentas de nuevo.

Un cuidado: si ejecutas git fetch justo antes, tu origin/main ya está actualizada, y el lease deja pasar el push aunque no hayas incorporado el commit de esa persona. Para cerrar ese hueco existe --force-if-includes, que comprueba que lo que está en el remoto también esté en tu branch. Lo probé: después de un git fetch, --force-with-lease solo pasó por encima del commit nuevo de la compañera, y con --force-if-includes el push fue rechazado:

$ git push --force-with-lease --force-if-includes origin main
 ! [rejected]        main -> main (remote ref updated since checkout)

Vale la pena un alias para no escribir esto cada vez:

git config --global alias.pushf "push --force-with-lease --force-if-includes"
git pushf

Y la regla de siempre: push forzado en tu branch, todo bien. En la main compartida, combínalo antes con el equipo (o deja la main protegida en GitHub).

git reflog: el deshacer de Git#

¿Un rebase salió mal? ¿Un reset --hard en el lugar equivocado? Calma. Casi nada se pierde de verdad en Git. git reflog guarda cada lugar por donde pasó tu HEAD, incluso commits que ya no aparecen en git log:

$ git reflog -6
9eadb5e HEAD@{0}: rebase (finish): returning to refs/heads/main
9eadb5e HEAD@{1}: commit (amend): add z
3a8f3fa HEAD@{2}: rebase (pick): add z
f7db88b HEAD@{3}: commit (amend): feat: add the profile page
8d7de9d HEAD@{4}: rebase (start): checkout HEAD~2
fba2c8f HEAD@{5}: rebase (finish): returning to refs/heads/main

Así deshice el rebase que cambió el autor del commit de mi compañera. HEAD@{5} era el estado anterior, entonces:

git reset --hard HEAD@{5}

Y todo volvió a como estaba. Antes de cualquier operación que te dé miedo, también puedes crear una branch de seguridad, que no cuesta nada:

git branch backup/before-rebase

Si algo sale mal, la branch está ahí, apuntando al commit de antes.

El reflog es local y no es eterno: por defecto, las entradas de commits que no están en ninguna branch caducan a los 30 días. Y un cambio que nunca tuvo commit ni se guardó en el stash, el reflog no lo puede salvar.

Resumen para pegar al lado del monitor#

Quiero...Comando
Guardar lo que no tiene commit y limpiar el directoriogit stash push -u -m "name"
Traerlo de vuelta del cajóngit stash pop
Renombrar un archivogit mv old new
Ver el historial de un archivo renombradogit log --follow -- file
Agregar un archivo olvidado al último commitgit add file && git commit --amend --no-edit
Ver qué llegó al remoto, sin tocar nadagit fetch && git log main..origin/main
Actualizar mi branch en línea rectagit rebase origin/main
Juntar o editar commits antes del PRgit rebase -i origin/main
Subir historial reescrito sin borrar el de nadiegit push --force-with-lease
Deshacer un desastregit reflog y git reset --hard HEAD@{n}

Conclusión#

¿Ves que no es un monstruo? Cuando ves los cinco lugares (directorio, stash, index, repositorio local y remoto), cada comando es solo una flecha entre ellos. Y con reflog en el bolsillo, equivocarse deja de dar miedo, porque casi todo tiene vuelta atrás.

¿Quieres practicar sin riesgo? Crea una carpeta, ejecuta git init y haz todos los ejemplos de este post ahí. Así probé cada comando de aquí.

Referencias#

  • Infra
  • git
  • terminal
  • rebase
  • control de versiones
  • productividad

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.