Tutorial de Historial de Git y Gestión de Logs

Introducción

¡Bienvenido, viajero del tiempo de Git! Hoy nos embarcaremos en un emocionante viaje a través del historial de tus proyectos de Git. Una de las características más potentes de Git es su capacidad para rastrear y mostrar la evolución de tu trabajo. Este historial no es solo un registro de lo que sucedió, sino una herramienta fundamental para comprender, depurar y mejorar tu proyecto.

En esta práctica de laboratorio, exploraremos el comando git log, que es tu ventana a los registros históricos de Git. Comenzaremos con el uso básico y luego profundizaremos en técnicas avanzadas como el formateo de la salida del log, el filtrado por fechas, la búsqueda de cambios específicos e incluso la generación de estadísticas a partir del historial de tu proyecto.

Al finalizar esta sesión, serás capaz de navegar por el historial de tu proyecto como un profesional, extrayendo información valiosa que te convertirá en un desarrollador más eficaz. Ya sea que estés rastreando un error, revisando cambios o simplemente tratando de entender cómo evolucionó tu código, las habilidades que aprenderás aquí serán invaluables.

¡Subamos a nuestra máquina del tiempo de Git y exploremos el pasado!

Configuración de tu Espacio de Trabajo

Antes de sumergirnos en las funciones del historial de Git, configuremos un espacio de trabajo con algo de historial de commits para explorar. Crearemos un nuevo directorio, inicializaremos un repositorio de Git y añadiremos algunos commits.

Abre tu terminal y escribe estos comandos:

cd ~/project
mkdir git-history-lab
cd git-history-lab
git init

Ahora, vamos a crear algunos archivos y realizar una serie de commits, copiando y pegando los siguientes comandos:

echo "## Git History Lab" > README.md
git add README.md
git commit -m "Initial commit"

echo "function hello() {" > script.js
echo "  console.log('Hello, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add hello function"

echo "function goodbye() {" >> script.js
echo "  console.log('Goodbye, Git!');" >> script.js
echo "}" >> script.js
git add script.js
git commit -m "Add goodbye function"

echo "This is a test file" > test.txt
git add test.txt
git commit -m "Add test file"

echo "hello();" >> script.js
echo "goodbye();" >> script.js
git add script.js
git commit -m "Call hello and goodbye functions"

Analicemos lo que acabamos de hacer:

Creamos un archivo README y realizamos nuestro commit inicial.
Creamos un archivo JavaScript con una función "hello" y lo confirmamos.
Añadimos una función "goodbye" al mismo archivo y realizamos el commit.
Añadimos un archivo de prueba y lo confirmamos.
Finalmente, modificamos nuestro script para llamar a ambas funciones y confirmamos los cambios.

¡Ahora tenemos un repositorio con historial suficiente para empezar a explorar!

Uso Básico del Log

Ahora que tenemos algo de historial de commits, exploremos el uso básico de git log.

Para ver el historial de commits de tu proyecto, simplemente ejecuta:

git log

Deberías ver una salida similar a esta:

commit 1234567890abcdef1234567890abcdef12345678 (HEAD -> main)
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 10:00:00 2023 +0000

    Call hello and goodbye functions

commit 2345678901abcdef2345678901abcdef23456789
Author: Your Name <your.email@example.com>
Date:   Mon Jun 5 09:45:00 2023 +0000

    Add test file

...

Cada entrada en el log muestra:

El hash completo del commit (un identificador único para el commit).
El autor del commit.
La fecha y hora del commit.
El mensaje del commit.

Por defecto, git log muestra todos los commits, comenzando por el más reciente. Los presenta en orden cronológico inverso (el más nuevo primero).

Si la salida es muy extensa, Git la mostrará en un paginador (normalmente less). Puedes navegar usando las teclas de flecha y presionar q para salir.

Para ver una versión más concisa del historial, puedes usar:

git log --oneline

Esto muestra cada commit en una sola línea, incluyendo solo el hash corto y el mensaje del commit.

Recuerda que git log es tu ventana al pasado del proyecto. Es un excelente punto de partida para entender qué cambios se han realizado, cuándo y por quién.

Formateo de la Salida del Log

Git ofrece opciones potentes para formatear la salida del log y mostrar exactamente la información que necesitas. Exploremos algunas de estas opciones.

Para ver los archivos que fueron modificados en cada commit, utiliza la opción --stat:

git log --stat

Esto te mostrará qué archivos cambiaron en cada commit y cuántas líneas se añadieron o eliminaron.

Para una vista más detallada de los cambios, utiliza la opción -p:

git log -p

Esto muestra el parche real (las líneas que se agregaron y eliminaron) de cada commit. Es muy útil para revisar los cambios en detalle.

También puedes crear formatos personalizados usando la opción --pretty. Por ejemplo:

git log --pretty=format:"%h - %an, %ar : %s"

Esto mostrará:

%h: hash de commit abreviado.
%an: nombre del autor.
%ar: fecha del autor, relativa (hace cuánto tiempo).
%s: asunto (mensaje del commit).

Puedes personalizar esta cadena de formato para incluir cualquier información que necesites. Aquí tienes algunos marcadores de posición útiles:

%H: hash de commit completo.
%ad: fecha del autor.
%cn: nombre de quien realiza el commit (committer).
%ce: correo electrónico del committer.
%cd: fecha del committer.

¡Experimenta con diferentes formatos para encontrar el que mejor se adapte a tus necesidades!

Filtrado del Log por Fecha

A menudo, querrás examinar los commits realizados en un rango de tiempo específico. Git proporciona varias opciones para filtrar el historial por fecha.

Para ver los commits de la última semana:

git log --since=1.week

También puedes usar fechas específicas:

git log --after="2023-06-01" --before="2023-06-30"

Esto mostrará los commits realizados entre el 1 y el 30 de junio de 2023.

Git entiende una gran variedad de formatos de fecha, incluyendo expresiones relativas como "yesterday" (ayer), "1 month 2 weeks 3 days ago" (hace 1 mes, 2 semanas y 3 días), etc.

También puedes usar la opción --until en lugar de --before, y --after es sinónimo de --since.

Ten en cuenta que estos filtros muestran los commits cuya fecha de creación cae dentro del rango especificado. La fecha del commit es el momento en que se creó el registro, que podría ser diferente de cuando se realizaron los cambios originales.

Si estás investigando cuándo se introdujo un cambio en particular, es posible que prefieras usar la opción --grep para buscar mensajes de commit específicos, lo cual veremos en el siguiente paso.

Búsqueda de Cambios Específicos en el Log

Git ofrece capacidades de búsqueda avanzadas para ayudarte a encontrar commits específicos. Exploremos algunas de estas funciones.

Para buscar commits que contengan una palabra específica en el mensaje:

git log --grep="function"

Esto mostrará todos los commits donde la palabra "function" aparezca en el mensaje descriptivo.

También puedes buscar cambios realizados en un archivo específico:

git log -- script.js

Esto muestra todos los commits que afectaron al archivo script.js.

Para buscar cambios que añadieron o eliminaron una línea de código específica:

git log -S "console.log"

Esto se conoce como búsqueda "pickaxe" (pico). Muestra los commits donde el número de ocurrencias de "console.log" cambió.

Puedes combinar estas opciones con otras. Por ejemplo, para ver los cambios detallados en script.js durante la última semana:

git log -p --since=1.week -- script.js

Recuerda que la búsqueda de Git distingue entre mayúsculas y minúsculas por defecto. Usa la opción -i para una búsqueda insensible a mayúsculas:

git log --grep="function" -i

Estas capacidades de búsqueda son increíblemente útiles cuando intentas rastrear cuándo se introdujo un cambio determinado o cuándo se solucionó un error.

Generación de Estadísticas desde el Log

Git puede proporcionar información valiosa sobre la evolución de tu proyecto a través de estadísticas. Veamos algunas formas de generarlas.

Para ver un resumen del número de commits por autor:

git shortlog -s -n

Esto muestra una lista de autores, ordenados por el número de commits, con el recuento al lado de cada nombre.

Para ver cuántas líneas ha añadido y eliminado cada autor:

git log --author="Jane Doe" --pretty=tformat: --numstat | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "Added lines: %s, Removed lines: %s, Total lines: %s\n", add, subs, loc }'

Sustituye "Jane Doe" por el nombre del autor que quieras consultar.

Para identificar qué archivos han cambiado con más frecuencia:

git log --pretty=format: --name-only | sort | uniq -c | sort -rg | head -10

Esto muestra los 10 archivos modificados con mayor frecuencia.

Para ver el número total de commits:

git rev-list --count HEAD

Estas estadísticas son muy útiles para comprender los patrones generales de desarrollo en tu proyecto. Pueden ayudarte a identificar qué partes del código son más activas, quiénes son los colaboradores principales y cómo ha crecido el proyecto con el tiempo.

Recuerda que, aunque estas estadísticas son informativas, no cuentan toda la historia. El número de commits o de líneas cambiadas no siempre se correlaciona con el impacto o la calidad de las contribuciones.

Resumen

¡Felicidades, historiador de Git! Acabas de desbloquear el potencial de las funciones de gestión de historial y logs de Git. Repasemos los conceptos clave que hemos tratado:

Uso Básico del Log: Aprendiste a visualizar el historial de commits de tu proyecto con git log.
Formateo de la Salida: Descubriste cómo personalizar la información mostrada para obtener exactamente lo que necesitas.
Filtrado por Fecha: Viste cómo enfocarte en commits dentro de rangos de tiempo específicos.
Búsqueda de Cambios: Aprendiste técnicas potentes para localizar cuándo se introdujeron cambios particulares.
Generación de Estadísticas: Exploraste formas de extraer información sobre los patrones de desarrollo de tu proyecto.

Estas habilidades serán invaluables a medida que trabajes en proyectos más grandes. Ya sea que estés rastreando un error, revisando la evolución de una funcionalidad o tratando de entender las tendencias generales de desarrollo, el comando git log y sus diversas opciones serán tus aliados fieles.

Recuerda, el historial de Git no es solo un registro estático; es una herramienta dinámica para comprender y mejorar tu trabajo. Úsalo con sabiduría y te convertirá en un desarrollador mucho más eficiente.

Sigue explorando y experimentando con estos comandos. Cuanto más cómodo te sientas navegando por el pasado de tu proyecto, más provecho podrás sacar de él. ¡Disfruta de tus viajes en el tiempo por tus repositorios de Git!