Cinco comandos de Git que te sacan de un apuro

Casi todos usamos siempre los mismos cuatro comandos de Git: add, commit, push, pull. Alcanzan para el día a día.

El problema aparece cuando algo sale mal. Ahí uno suele resolverlo copiando la carpeta a otro lado por las dudas, clonando el repositorio de nuevo, o pegando los cambios a mano en un archivo nuevo.

Estos cinco comandos resuelven esas situaciones directamente. No hace falta aprenderlos de memoria: alcanza con saber que existen para buscarlos cuando llegue el momento.

1. git reflog — recuperar lo que borraste

Cuándo: hiciste algo que borró trabajo. Un reset --hard de más, una rama eliminada, un rebase que salió mal. Los commits parecen no existir.

Git guarda un registro de todo lugar donde estuviste, aunque ya no haya nada que apunte ahí:

git reflog

a3f21c9 HEAD@{0}: reset: moving to HEAD~3
8b4d012 HEAD@{1}: commit: agregar validación de correo
1c9e5a7 HEAD@{2}: commit: corregir cálculo de envío

Ahí está 8b4d012, el commit que creías perdido. Para volver:

git reset --hard 8b4d012

Lo importante de saber: Git no borra los commits enseguida. Los conserva unos treinta días aunque nada los referencie. Casi todo lo que creés que perdiste sigue estando.

Es el comando que más veces me sacó de un problema, y el que más gente no sabe que existe.

2. git bisect — encontrar cuándo se rompió

Cuándo: algo funcionaba hace dos semanas y ahora no. Hay ciento cuarenta commits en el medio y no tenés idea de cuál lo rompió.

La alternativa manual es ir probando commits al azar. bisect lo hace por búsqueda binaria: en siete pasos revisa ciento cuarenta commits.

git bisect start
git bisect bad                # el actual está roto
git bisect good v1.4.0        # esta versión andaba

Git te deja parado en un commit del medio. Probás, y le decís cómo salió:

git bisect good     # o "git bisect bad"

Repetís unas siete veces y te dice exactamente cuál fue:

8b4d0129a3f21c9e5a7b4d012 is the first bad commit

Al terminar, git bisect reset te devuelve donde estabas.

El truco que lo vuelve automático: si podés escribir un comando que devuelva error cuando está roto, Git hace todo solo.

git bisect start HEAD v1.4.0
git bisect run npm test

Te vas a tomar un café y volvés con el commit culpable identificado.

3. git revert — deshacer algo que ya subiste

Cuándo: subiste un commit que rompe producción y hay que sacarlo ya.

La tentación es reset --hard y push --force. No hagas eso en una rama compartida: reescribe el historial que otros ya descargaron, y a todo el equipo se le va a romper el siguiente pull.

revert crea un commit nuevo que deshace los cambios del anterior:

git revert a3f21c9

El historial queda intacto y crece hacia adelante. Nadie tiene que hacer nada especial.

La diferencia en una línea: reset finge que nunca pasó; revert deja constancia de que pasó y de que lo deshiciste. En una rama compartida, siempre revert.

4. git stash — guardar lo que estás haciendo sin comprometerte

Cuándo: estás a la mitad de algo y aparece una urgencia. Tus cambios no están listos para un commit, pero necesitás cambiar de rama.

git stash push -m "validación a medias"
git switch main          # ahora sí, la urgencia
# ... resolvés ...
git switch mi-rama
git stash pop            # vuelven tus cambios

Dos cosas que casi nadie sabe y que evitan sorpresas:

Los archivos nuevos no se guardan por omisión. Si creaste un archivo y todavía no le hiciste git add, stash lo ignora y queda ahí. Para incluirlos:

git stash push -u -m "con archivos nuevos"

pop borra el guardado, apply lo conserva. Si no estás seguro de que va a aplicar limpio, usá apply primero y borralo después con git stash drop.

5. git add -p — subir solo una parte de lo que cambiaste

Cuándo: tocaste un archivo para arreglar un error, y de paso corregiste una sangría y renombraste una variable. Querés que el commit tenga solo el arreglo.

git add -p archivo.js

Git te muestra cada bloque de cambios y pregunta qué hacer:

¿Preparar este fragmento [y,n,q,a,d,s,e,?]?

y lo incluye, n lo saltea, y s divide un bloque grande en partes más chicas si quedaron mezcladas.

No es un comando de emergencia como los otros cuatro, pero es el que más mejora tus commits. Un commit que hace una sola cosa se entiende de un vistazo seis meses después — y se puede revertir sin arrastrar cambios que no tenían nada que ver.

Lo que estos cinco tienen en común

Ninguno se usa todos los días. Todos aparecen en el momento en que algo salió mal y estás con menos paciencia que de costumbre.

Por eso conviene leerlos ahora, tranquilo, y no la primera vez que los necesites. No hace falta recordar la sintaxis; alcanza con recordar que el comando existe.

Y el más importante de los cinco, si te quedás con uno: git reflog. Lo que creés que perdiste probablemente siga ahí.