Visualización del historial

Historial de cambios con git log

El comando git log es la herramienta principal para explorar el historial de commits de un repositorio. Este comando te permite visualizar información detallada sobre los cambios realizados a lo largo del tiempo, incluyendo quién hizo cada cambio, cuándo se realizó y qué mensaje descriptivo se incluyó.

Uso básico de git log

La forma más simple de usar git log es ejecutarlo sin parámetros adicionales:

git log

Este comando muestra una lista cronológica de todos los commits, comenzando por el más reciente. Cada entrada incluye:

• Hash del commit: Identificador único de 40 caracteres
• Autor: Nombre y email de quien realizó el commit
• Fecha: Momento exacto en que se creó el commit
• Mensaje: Descripción del cambio realizado

La salida típica se ve así:

commit a1b2c3d4e5f6789012345678901234567890abcd
Author: María García <maria@empresa.com>
Date:   Mon Dec 4 14:30:22 2023 +0100

    Añadir validación de formulario de contacto

commit f9e8d7c6b5a4321098765432109876543210fedc
Author: Juan Pérez <juan@empresa.com>
Date:   Mon Dec 4 10:15:45 2023 +0100

    Corregir error en cálculo de precios

Opciones de formato más útiles

El comando git log ofrece múltiples opciones para personalizar la salida según tus necesidades:

Formato compacto con --oneline:

git log --oneline

Esta opción muestra cada commit en una sola línea, incluyendo solo los primeros 7 caracteres del hash y el mensaje:

a1b2c3d Añadir validación de formulario de contacto
f9e8d7c Corregir error en cálculo de precios
b4c5d6e Actualizar documentación de API

Visualización gráfica con --graph:

git log --graph --oneline

Añade una representación visual de las ramas y merges, especialmente útil en proyectos con múltiples ramas:

* a1b2c3d Añadir validación de formulario de contacto
* f9e8d7c Corregir error en cálculo de precios
*   b4c5d6e Merge branch 'feature/api-update'
|\
| * c7d8e9f Actualizar endpoints de usuario
* | a2b3c4d Mejorar manejo de errores
|/
* e5f6g7h Commit inicial

Filtrado por cantidad y tiempo

Para evitar que la salida sea abrumadora, puedes limitar la cantidad de commits mostrados:

git log -5

Este comando muestra únicamente los últimos 5 commits. También puedes filtrar por rango de fechas:

git log --since="2023-12-01" --until="2023-12-31"

O usar formatos más naturales:

git log --since="2 weeks ago"
git log --since="yesterday"

Filtrado por autor y contenido

Puedes buscar commits de un autor específico:

git log --author="María García"

O buscar commits que contengan palabras clave en el mensaje:

git log --grep="validación"

Para buscar cambios en archivos específicos:

git log -- src/components/ContactForm.js

Información estadística

El parámetro --stat añade estadísticas sobre los archivos modificados:

git log --stat --oneline

Muestra qué archivos se modificaron y cuántas líneas se añadieron o eliminaron:

a1b2c3d Añadir validación de formulario de contacto
 src/components/ContactForm.js | 15 +++++++++++++++
 src/utils/validation.js       |  8 ++++++++
 2 files changed, 23 insertions(+)

Formato personalizado

Git permite crear formatos personalizados usando placeholders:

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

Donde:

• %h: Hash abreviado
• %an: Nombre del autor
• %ar: Fecha relativa
• %s: Mensaje del commit

Resultado:

a1b2c3d - María García, hace 2 horas : Añadir validación de formulario de contacto
f9e8d7c - Juan Pérez, hace 6 horas : Corregir error en cálculo de precios

Navegación en el historial

Cuando el historial es extenso, git log utiliza un paginador (normalmente less). Puedes navegar usando:

• Espacio: Avanzar una página
• b: Retroceder una página
• q: Salir del paginador
• /texto: Buscar texto específico

Integración con Visual Studio Code

Aunque el terminal es fundamental para dominar Git, Visual Studio Code ofrece una interfaz gráfica intuitiva para visualizar el historial. Puedes acceder a través de la pestaña "Source Control" y hacer clic en el icono del reloj para ver el historial de commits de forma visual, complementando perfectamente el trabajo con comandos.

El comando git log es esencial para entender la evolución de tu proyecto y rastrear cambios específicos. Dominar sus diferentes opciones te permitirá navegar eficientemente por el historial y encontrar la información que necesitas en cualquier momento del desarrollo.

Detalles con git show

Mientras que git log te proporciona una vista general del historial, el comando git show se especializa en mostrar información detallada de commits específicos. Este comando es fundamental cuando necesitas examinar exactamente qué cambios se realizaron en un commit particular, incluyendo el contenido completo de las modificaciones.

Uso básico de git show

La forma más directa de usar git show es especificando el hash de un commit:

git show a1b2c3d4

Este comando muestra información completa del commit, incluyendo:

• Metadatos del commit: autor, fecha y mensaje
• Diferencias completas: líneas añadidas y eliminadas
• Contexto de los cambios: líneas circundantes para mejor comprensión

La salida típica incluye tanto la información del commit como el diff completo:

commit a1b2c3d4e5f6789012345678901234567890abcd
Author: María García <maria@empresa.com>
Date:   Mon Dec 4 14:30:22 2023 +0100

    Añadir validación de formulario de contacto

diff --git a/src/components/ContactForm.js b/src/components/ContactForm.js
index 1234567..abcdefg 100644
--- a/src/components/ContactForm.js
+++ b/src/components/ContactForm.js
@@ -15,6 +15,12 @@ function ContactForm() {
   const handleSubmit = (e) => {
     e.preventDefault();
+    
+    if (!email.includes('@')) {
+      setError('Email inválido');
+      return;
+    }
+    
     // Enviar formulario
   };

Mostrar el último commit

Si no especificas un hash, git show muestra automáticamente el último commit (HEAD):

git show

Esto es especialmente útil para revisar rápidamente los cambios más recientes que acabas de realizar.

Mostrar commits específicos por referencia

Puedes usar diferentes formas de referenciar commits:

Por posición relativa:

git show HEAD~1    # Commit anterior al último
git show HEAD~2    # Dos commits atrás

Por rama:

git show main      # Último commit de la rama main
git show feature/login  # Último commit de una rama específica

Mostrar solo archivos modificados

Para ver únicamente qué archivos se modificaron sin el contenido detallado:

git show --name-only a1b2c3d4

Resultado:

src/components/ContactForm.js
src/utils/validation.js
tests/ContactForm.test.js

Si quieres incluir el tipo de cambio (modificado, añadido, eliminado):

git show --name-status a1b2c3d4

Resultado:

M    src/components/ContactForm.js
A    src/utils/validation.js
M    tests/ContactForm.test.js

Donde M indica modificado y A indica añadido.

Mostrar estadísticas de cambios

Para obtener un resumen estadístico de los cambios:

git show --stat a1b2c3d4

Esta opción muestra cuántas líneas se añadieron o eliminaron en cada archivo:

commit a1b2c3d4e5f6789012345678901234567890abcd
Author: María García <maria@empresa.com>
Date:   Mon Dec 4 14:30:22 2023 +0100

    Añadir validación de formulario de contacto

 src/components/ContactForm.js | 15 +++++++++++++++
 src/utils/validation.js       |  8 ++++++++
 tests/ContactForm.test.js     | 12 ++++++++++++
 3 files changed, 35 insertions(+)

Mostrar archivos específicos

Puedes limitar la salida a archivos específicos añadiendo la ruta al final del comando:

git show a1b2c3d4 -- src/components/ContactForm.js

Esto muestra únicamente los cambios realizados en ese archivo particular, ignorando las modificaciones en otros archivos del mismo commit.

Formato de salida personalizado

Al igual que con git log, puedes personalizar el formato de la información del commit:

git show --pretty=format:"%h - %an: %s" --name-only a1b2c3d4

Resultado:

a1b2c3d - María García: Añadir validación de formulario de contacto
src/components/ContactForm.js
src/utils/validation.js
tests/ContactForm.test.js

Mostrar múltiples commits

Puedes mostrar varios commits específicos en una sola ejecución:

git show a1b2c3d4 f9e8d7c6 b4c5d6e7

Cada commit se mostrará por separado con toda su información detallada.

Integración práctica con el flujo de trabajo

El comando git show es especialmente útil en situaciones como:

• Revisión de código: Examinar cambios específicos antes de hacer merge
• Debugging: Identificar exactamente qué se modificó en un commit problemático
• Documentación: Entender el contexto completo de un cambio específico

Visual Studio Code también proporciona una vista detallada de commits individuales. Puedes hacer clic en cualquier commit del historial para ver una representación visual similar a git show, con la ventaja de poder navegar fácilmente entre archivos modificados.

La combinación de git log para explorar el historial y git show para examinar detalles específicos te proporciona un control completo sobre la información de tu repositorio, permitiéndote entender tanto el panorama general como los detalles específicos de cualquier cambio.