Git Reflog: Comprender y utilizar los registros de referencia en Git

No hay nada más molesto para un desarrollador o ingeniero de datos que borrar accidentalmente ramas git o restablecer commits cuando no querías hacerlo. Por eso me complace compartir algo que aprendí por experiencia propia y que desearía haber aprendido antes, que es utilizar git reflog. git reflog es una de esas técnicas que definitivamente merece la pena aprender; si dedicas un poco de tiempo ahora, puedes ahorrarte un gran dolor de cabeza más adelante. 

Aunque te mostraré git reflog, que me resulta muy útil para navegar y recuperarme de los errores, también quiero recomendarte nuestros cursos Fundamentos de Git e Introducción a los conceptos de GitHub para aprender todo lo que hay que saber sobre el control de versiones.

¿Qué es git reflog?

Git reflog, o registro de referencias, es un mecanismo de seguimiento local que registra las actualizaciones de las puntas de rama y la referencia HEAD en un repositorio Git. (En el contexto de Git, HEAD se refiere a la confirmación actual en la que se basan tu directorio de trabajo y tu área de preparación).

A diferencia de git log, que muestra el historial de confirmaciones basado en la ascendencia, mostrando cómo se conectan las confirmaciones en una rama, git reflog captura todos los movimientos de HEAD, incluidos los cambios de rama, los rebases, los reinicios y las confirmaciones. Esto hace que reflog sea útil para recuperar confirmaciones perdidas y depurar acciones recientes.

¿Cuándo se crean las entradas reflog?

Las entradas Reflog se crean siempre que realizas acciones que cambian el estado de las referencias HEAD o rama. Entre las situaciones más habituales se encuentran las siguientes:

• Confirmación de cambios mediante git commit.

• Consulta una rama diferente utilizando git checkout branch_name.

• Crear una nueva rama utilizando git branch new_branch.

• Rebasado git rebase

• Restablecer un commit anterior git reset --hard.

• Fusión de ramas mediante git merge.

Este es el código que utilizas para realizar un seguimiento de las actualizaciones en el repositorio local:

git reflog

Utilizando git reflog para realizar un seguimiento de las actualizaciones en el repositorio local. Imagen del autor.

¿Cómo interpretas la salida de git reflog?

Puedes interpretar el resultado del siguiente modo:

• HEAD@{0}: La acción más reciente fue cambiar a la rama HEAD.

• HEAD@{1}: Antes había cambiado un tipo de archivo del formato .xlxs al formato .csv.

• HEAD@{2}: Hice el primer commit al enviar los archivos al repositorio.

Cada entrada muestra:

• El hash de la confirmación (fa82776)

• El índice reflog (HEAD@{0}, HEAD@{1}, etc.)

• Una descripción de la acción realizada (commit, checkout, rebase)

Cómo utilizar git reflog

Git reflog proporciona una forma de seguir las actualizaciones de las referencias y restaurar los estados anteriores de tu repositorio. Si sabes cómo navegar por las entradas de reflog, podrás recuperar confirmaciones perdidas, deshacer cambios y comparar versiones anteriores de tu trabajo. 

Comando git reflog básico

A continuación se muestra el comando reflog básico:

git reflog

El comando anterior muestra una lista de acciones recientes que actualizaron referencias HEAD o de rama, incluyendo confirmaciones, cambios de rama, reinicios, rebases y más. Cada entrada está indexada, como HEAD@{0}, y HEAD@{1}, para representar su posición en el historial reflog.

Referencia a estados anteriores

Git reflog sirve como registro de actualizaciones de referencias pasadas, permitiéndonos localizar y restaurar puntos anteriores en la historia de nuestro repositorio. Sin ella, estas referencias no existirían, y necesitaríamos hashes de confirmación exactos para volver a estados pasados concretos. Ahora, vamos a explorar cómo Git nos permite navegar por estos estados pasados utilizando git checkout.

HEAD@{n}: Hace referencia a una entrada reflog concreta, donde n es el índice. Por ejemplo, HEAD@{2} se refiere al tercer estado más reciente de HEAD.

git checkout HEAD@{2}

Utilizar git checkout para rastrear cambios anteriores. Imagen del autor.

branch@{time}: Se refiere al estado de una rama en un momento determinado. Por ejemplo, main@{1.week.ago} se refiere al estado de la rama principal hace una semana, mientras que feature@{yesterday} se refiere al estado de la rama de características ayer.

git checkout main@{1.week.ago}

Utilizar git checkout para rastrear cambios anteriores. Imagen del autor.

Clasificaciones por tiempo

git reflog no sólo nos ayuda a restaurar estados pasados, sino que también nos permite compararlos. Como reflog hace un seguimiento de las actualizaciones de las referencias, podemos utilizarlo para ver cómo ha cambiado nuestro repositorio a lo largo del tiempo. Ahora, veamos cómo git diff utiliza las entradas reflog para comparar estados pasados y presentes.

Los siguientes son ejemplos de calificadores temporales que facilitan la restauración de tu repositorio a un punto concreto en el tiempo, en lugar de depender únicamente de los números de índice de reflog.

git checkout HEAD@{1.minute.ago}     # State from one minute ago

git checkout HEAD@{1.hour.ago}       # State from one hour ago

git checkout HEAD@{1.week.ago}       # State from one week ago

git checkout HEAD@{yesterday}        # State from yesterday

git checkout HEAD@{2024-01-01.12:00:00} # State at a specific timestamp

Comparar estados anteriores con git diff

Puedes comparar estados anteriores utilizando comandos como git diff. El siguiente comando compara el estado actual de la rama principal main@{0} con su estado de hace un día, main@{1.day.ago}. El resultado mostrará las diferencias entre estas dos instantáneas.

git diff main@{0} main@{1.day.ago}

Comparar estados anteriores con git diff. Imagen del autor.

Casos comunes de uso de Git Reflog

Git reflog es una herramienta inestimable para recuperar cambios perdidos, deshacer errores y arreglar contratiempos comunes de Git. A continuación se exponen algunos supuestos prácticos en los que git reflog puede ser de ayuda.

Deshacer un reinicio incorrecto

Si por error restableces tu rama utilizando git reset --hard, puedes utilizar reflog para restaurar su estado anterior.

git reset --hard HEAD@{3}

Recuperar commits perdidos

Si borras accidentalmente una rama o pierdes confirmaciones debido a un reset o rebase, puedes encontrar la confirmación perdida utilizando git reflog.

git reflog

Localiza el hash de confirmación de la salida de reflog y compruébalo:

git checkout <commit-hash>

Una vez verificada la confirmación perdida, puedes crear una nueva rama para conservarla:

git branch recovered-branch <commit-hash>

Arreglar un rebase chapucero

Si un rebase sale mal, puedes utilizar git reflog para encontrar el commit anterior al rebase y restablecer tu rama. Identifica el commit anterior al rebase y reinícialo.

git reset --hard HEAD@{3}  # Adjust the number based on the reflog output

Restaurar una rama eliminada

Si borras accidentalmente una rama, puedes recuperarla utilizando git reflog. Busca la última confirmación conocida de la rama eliminada y vuelve a crearla:

git branch restored-branch <commit-hash>

Seguimiento del historial de alijo

Git reflog también se puede utilizar para ver el historial del alijo. El comando siguiente enumera las operaciones de alijo, permitiéndote recuperar alijos antiguos si es necesario. 

git reflog stash

Para aplicar una entrada de alijo anterior, utiliza el siguiente comando:

git stash apply stash@{2}

Consulta nuestra página Git Pull Force: Tutorial Cómo sobrescribir una rama local con una remota para aprender las mejores prácticas para sobrescribir cambios locales.

Subcomandos y opciones de Git Reflog

Git proporciona varios subcomandos y opciones para gestionar e interactuar con los reflogs. 

Subcomandos de Git reflog

A continuación encontrarás un desglose estructurado de los subcomandos clave de git reflog y su uso.

git reflog show: Muestra las entradas reflog para HEAD por defecto o para una referencia especificada como una rama.

git reflog show

Utiliza git reflog show para mostrar las entradas de la referencia especificada. Imagen del autor.

git reflog list: Este comando muestra todas las referencias con un reflog. Es útil para identificar ramas y referencias HEAD con entradas reflog almacenadas.

git reflog list

git reflog delete @{}: Limpia las entradas antiguas de reflog que superan el límite de tiempo especificado. Por ejemplo, el siguiente comando elimina las entradas con más de 30 días de antigüedad.

git reflog expire --expire=30.days.ago

git reflog delete @{}: Elimina una entrada reflog concreta en función de su referencia y posición. El siguiente comando elimina la entrada reflog en el índice 2 para HEAD.

git reflog delete HEAD@{2}

git reflog exists : Comprueba si existe un reflog para una referencia concreta. Por ejemplo, el comando siguiente tiene éxito si la rama principal tiene un reflog.

git reflog exists main

Opciones de los subcomandos de git reflog

A continuación se indican las opciones disponibles para los subcomandos de git reflog y su uso.

--expire-unreachable=: Elimina sólo las entradas de reflog que sean inalcanzables desde cualquier ref. Por ejemplo, el siguiente comando elimina las entradas reflog inalcanzables con más de 7 días de antigüedad.

git reflog expire --expire-unreachable=7.days.ago

--all: Procesa los reflogs de todas las referencias, no sólo de HEAD. El comando siguiente limpia todos los reflogs de más de 60 días en todas las ramas.

git reflog expire --expire=60.days.ago --all

--dry-run: Simula la ejecución de una orden, mostrando lo que se podaría sin borrar nada realmente. Por ejemplo, el comando siguiente muestra qué entradas se eliminarían.

git reflog expire --expire=30.days.ago --dry-run

--verbose: Proporciona información detallada sobre las acciones realizadas por el comando. El comando que aparece a continuación muestra detalles verbose al caducar entradas antiguas de reflog.

git reflog expire --expire=90.days.ago --verbose

Git Reflog frente a Registro Git: Diferencias clave

Tanto git log como git reflog proporcionan información sobre el historial de un repositorio, pero sirven para fines distintos. Veamos estas diferencias para comprender cómo puede utilizarse cada una para el control de versiones y las estrategias de recuperación.

• git log muestra el historial de confirmaciones siguiendo la ascendencia de las confirmaciones de una rama. Proporciona una visión cronológica de cómo evolucionó el contenido del repositorio.

• git reflog Registra las actualizaciones de referencias como HEAD, ramas y stashes, incluyendo acciones como cambios de rama, reinicios, rebases, etc. Realiza un seguimiento de los cambios que pueden no formar parte de la ascendencia de la confirmación.

• git reflog es estrictamente local a tu máquina y no se comparte con repositorios remotos.

• Mientras que git log no puede recuperar confirmaciones que ya no forman parte de la ascendencia de la rama, git reflog puede ayudar a recuperar confirmaciones "perdidas" mediante el seguimiento de las actualizaciones de las referencias, incluso si esas confirmaciones ya no son accesibles desde ninguna rama.

El cuadro siguiente resume estas diferencias clave.

Git reflog es una potente herramienta para recuperar confirmaciones perdidas y arreglar problemas del historial, pero utilizarla eficazmente requiere precaución. Éstas son algunas de las mejores prácticas que debes seguir cuando trabajes con reflog.

• Utiliza Reflog para Recuperación y Depuración: Si accidentalmente restableces o rebasas una rama de forma incorrecta, consulta git reflog para encontrar una referencia anterior y restablecerla.

• Ten cuidado con git reset --hard: git reset --hard puede eliminar permanentemente los cambios no comprometidos. Comprueba siempre primero el reflog para asegurarte de que puedes recuperarte si algo va mal.

• Guarda copias de seguridad antes de ejecutar comandos destructivos: Para protegerte contra la pérdida de datos, realiza copias de seguridad automáticas de tus repositorios Git. Almacena siempre las copias de seguridad en una ubicación segura y externa para garantizar la recuperabilidad en caso de fallo del hardware u otras catástrofes.

• No confíes únicamente en el Reflog para una recuperación a largo plazo: Por defecto, las entradas de reflog se guardan durante 90 días. Después de este periodo, pueden ser recolectados como basura y volverse irrecuperables. Envía regularmente tus commits a un repositorio remoto para asegurarte de que se conservan más allá de tu reflog local.

• Utiliza git reflog expire para gestionar entradas antiguas: Si el reflog de tu repositorio se satura, poda las entradas antiguas o inalcanzables utilizando git reflog expire.

Conclusión

Gestionar eficazmente el historial de un proyecto en Git requiere algo más que comandos básicos. Explorar las herramientas avanzadas que rastrean las actualizaciones de las referencias puede proporcionar una valiosa red de seguridad para recuperar commits perdidos, restaurar ramas eliminadas y corregir errores. Adquirir experiencia práctica con estas herramientas, junto con comandos como git reset, git checkout, y git revert, puede mejorar significativamente tu competencia en el control de versiones.

Hacer cursos de DataCamp no sólo es una forma estupenda de aprender, sino también de indicar a los empresarios que te tomas en serio el desarrollo de software. Para ello, te recomiendo que estudies nuestra entrada del blog Las 20 mejores preguntas y respuestas para entrevistas sobre Git para todos los niveles y que sigas nuestro nuevo curso de habilidades Fundamentos de Git para convertirte en un experto en todo lo relacionado con Git.