git log: cómo ver y navegar el historial

Acabas de hacer tus primeros commits. Con ilusión, escribes git log para ver qué has guardado, y la terminal te vomita una pantalla entera de texto que no cabe, con un signo raro abajo del todo, y de repente no responde a nada. Tranquila: no has roto nada. Ese muro de texto ES tu historial, y aquí aprendes a leerlo, a moverte por él y a salir de esa pantalla sin cerrar la terminal a lo bruto.

Para seguir este post solo necesitas saber una cosa: qué es un commit. Un commit es una foto guardada de tu proyecto en un momento concreto, con un mensaje que explica qué cambiaste. Si has hecho git add y git commit al menos una vez, ya tienes historial. Y git log es el comando para verlo. Si todavía te suena a chino todo esto, empieza por la guía de qué es Git y sus primeros pasos y vuelve luego.

¿Qué es el historial y por qué git log te lo enseña?

El historial es la lista de todos los commits que has hecho en el repositorio, ordenados del más reciente al más antiguo. Cada vez que haces git commit, Git añade una foto nueva encima de la anterior. Con el tiempo se forma una cadena: commit tras commit, cada uno apuntando al que vino antes.

Piensa en el historial como el registro de mensajes de un chat. Cada mensaje tiene una hora, quién lo escribió y el texto. Un commit es igual: tiene una fecha, un autor y un mensaje. git log es la ventana que te enseña esa conversación entera, desde el último mensaje hacia arriba.

Lo primero que conviene grabarse, sobre todo si estás empezando y todo te da un poco de respeto: git log es de solo lectura. Solo enseña. No borra commits, no cambia archivos, no toca nada de tu proyecto. Puedes ejecutarlo mil veces seguidas y tu código seguirá exactamente igual.

Cómo leer la salida de git log

La forma más básica es escribir el comando a secas:

# Muestra el historial completo, del commit más reciente al más antiguo
git log

Y esto es lo que Git te devuelve para cada commit:

commit 7b2e0d4f1a9c3e5b8d2f0a4c6e1b9d3a5f7c2e0b
Author: Sofía Ramírez <sofia@ejemplo.com>
Date:   Wed Aug 20 10:32:18 2026 +0200

    Añade validación al formulario de registro

Vamos línea por línea, porque cada una te dice algo:

• commit 7b2e0d4... es el hash del commit: un identificador único, una especie de matrícula. Son 40 caracteres en hexadecimal (números del 0 al 9 y letras de la a a la f). No hay dos commits con el mismo hash.
• Author es quién hizo el commit: el nombre y el email que configuraste en Git.
• Date es la fecha y hora exactas en que se guardó.
• La línea indentada de abajo es tu mensaje de commit, ese texto que escribiste para explicar qué cambiaste.

Si tienes muchos commits, Git no te los suelta todos de golpe. Los abre en un pager, un visor que se llama less, para que puedas leerlos poco a poco sin que se te escapen por arriba. Aquí está la trampa que asusta a casi todo el mundo la primera vez.

Cuando ves esa pantalla llena de texto y abajo aparece un : (dos puntos) o algo como (END), la terminal no está colgada. Está esperando a que le digas qué hacer. Bajas con la flecha o con la barra espaciadora, subes con la flecha de arriba, y cuando quieras salir pulsas la tecla q (de quit, salir). Eso te devuelve al terminal normal. No pulses Ctrl+C a lo loco ni cierres la ventana: solo q.

Ese pánico al pager es de lejos el tropiezo número uno de quien empieza. Recuérdalo así: si te quedas atrapada en una pantalla de texto tras un comando de Git, prueba primero con q.

git log —oneline: el historial en una línea por commit

git log --oneline resume cada commit en una única línea: el hash corto y el mensaje, nada más. Es la vista que vas a usar casi siempre, porque el formato largo, con autor y fecha en tres líneas, ocupa muchísimo cuando solo quieres una foto rápida de lo que has hecho.

# Una línea por commit: hash abreviado + mensaje
git log --oneline

7b2e0d4 Añade validación al formulario de registro
a3f9c21 Crea la página de registro
c58d17e Configura el proyecto inicial

Mucho más legible, ¿verdad? De un vistazo ves toda tu historia. Fíjate en el hash: aquí sale cortito (7b2e0d4), solo los primeros caracteres. Es el mismo identificador que antes tenía 40 caracteres, pero Git te enseña una versión abreviada porque con los primeros 7 suele bastar para distinguir un commit de otro.

Ese hash corto no tienes que memorizarlo ni copiarlo a mano con cuidado de no equivocarte. Cuando en el futuro un comando te pida un commit concreto, lo seleccionas de aquí y lo copias y pegas. Es una referencia para la máquina, no un número que tengas que aprenderte.

¿Qué es HEAD y por qué aparece en el log?

HEAD es el puntero a tu posición actual: el commit sobre el que estás trabajando ahora mismo. Cuando haces un commit nuevo, se guarda justo encima de donde apunta HEAD, y HEAD avanza para señalar ese commit recién creado.

La analogía que a mí me sirve es la del marcapáginas. HEAD es el punto de libro que tienes metido en tu proyecto: marca en qué página estás. Casi siempre está en el último commit de tu rama, que es donde escribes. Al ejecutar git log lo verás aparecer arriba del todo, entre paréntesis:

7b2e0d4 (HEAD -> main) Añade validación al formulario de registro
a3f9c21 Crea la página de registro
c58d17e Configura el proyecto inicial

Eso de HEAD -> main significa: estás situada en el commit 7b2e0d4, y ese commit es la punta de tu rama main. Dicho de otro modo, HEAD te dice dónde estás y main te dice el nombre de la rama en la que estás. Por ahora te vale con quedarte con la idea de HEAD como “aquí estoy yo”.

Ver las ramas con git log —oneline —graph

git log --oneline --graph dibuja la forma de tu historial como un árbol de líneas ASCII a la izquierda de los commits. Mientras trabajas en una sola rama, el historial es una columna recta y este comando no aporta gran cosa. Su momento llega cuando hay ramas que se separan y se vuelven a juntar.

Imagina para este ejemplo un proyecto algo más movido que el anterior, uno en el que se abrió una rama para el login y luego se fusionó de vuelta:

# Añade un árbol de ramas y fusiones a la izquierda del log
git log --oneline --graph

*   9d1a4f0 (HEAD -> main) Fusiona la rama login
|\
| * 4e7b2c9 Añade el botón de login
| * a3f9c21 Crea la página de registro
|/
* c58d17e Configura el proyecto inicial

Los asteriscos son los commits. Las líneas con |, \ y / muestran cómo una rama se separó del tronco principal para meter el login y luego volvió a fusionarse. Al principio esto se ve confuso, y no pasa nada por dejarlo aparcado. Guárdalo para el día en que tu equipo trabaje con varias ramas y quieras entender de un golpe de vista qué se juntó con qué.

Filtrar el historial cuando ya tienes muchos commits

Cuando el proyecto crece, ver el historial entero se vuelve incómodo. Git te deja recortarlo, y todas las opciones se combinan con --oneline sin problema.

Para ver solo los últimos commits, usa -n seguido de un número (existe también la forma corta pegada, -3):

# Solo los 3 commits más recientes
git log -n 3 --oneline

Para ver solo los commits de una persona, usa --author con parte de su nombre o su email:

# Solo los commits cuyo autor coincide con "sofia"
git log --author="sofia" --oneline

Y para ver solo los commits que tocaron un archivo concreto, pon el nombre del archivo después de un doble guion (--). Ese -- es un separador que le dice a Git “lo que viene ahora es un archivo, no una opción”, y evita que se confunda si el archivo se llama igual que una rama:

# Solo los commits que modificaron ese archivo
git log --oneline -- src/registro.js

No tienes que aprenderte los filtros de memoria hoy. Basta con saber que existen para el día que pienses “¿cuándo toqué yo este archivo?“.

git log vs —oneline vs —graph: cuál usar y cuándo

Comando	Qué muestra	Cuándo usarlo
git log	Todo el detalle: hash largo, autor, fecha y mensaje, un bloque por commit	Cuando necesitas datos completos de un commit: quién y cuándo
git log --oneline	Una línea por commit (hash corto + mensaje)	El día a día. Para ojear rápido qué has hecho
git log --oneline --graph	Lo mismo que —oneline más un árbol de ramas a la izquierda	Cuando hay varias ramas y quieres ver cómo se separan y fusionan

Si tuviera que quedarme con una sola, sería git log --oneline. Es la que abro sin pensar cada vez que quiero situarme en un proyecto.

Ahora te toca a ti. En vez de leerlo, pruébalo: aquí tienes un historial de ejemplo sobre el que practicar los comandos que acabas de ver.

Cargando ejercicio...

Errores comunes al empezar con git log

Creer que la terminal se ha colgado

Es el susto clásico. Escribes git log, aparece un muro de texto, la terminal deja de responder a lo que tecleas y cunde el pánico. No está colgada: es el pager less esperando órdenes. Pulsa q y vuelves a la normalidad. Esta sola tecla te ahorra cerrar la terminal cincuenta veces.

Pensar que git log cambia algo

Algunos comandos de Git dan respeto porque modifican tu proyecto. git log no es uno de ellos. Es de solo lectura de principio a fin: puedes ejecutarlo, filtrarlo y combinar opciones tantas veces como quieras sin que tu código ni tu historial se muevan un milímetro.

Intentar memorizar el hash corto

El hash es una matrícula para la máquina, no un número para tu cabeza. Nadie memoriza 7b2e0d4. Cuando lo necesites, lo copias del log y lo pegas donde haga falta.

Esperar ver qué líneas cambiaron

Aquí conviene tener clara la frontera. git log te dice QUÉ commits existen y qué mensaje tienen, pero no te enseña las líneas de código que cambiaron dentro de cada uno. Para ver el contenido de los cambios, línea a línea, el comando es git diff, y lo cuento en detalle en la guía sobre cómo ver los cambios con git diff.

De leer el historial a moverte por él

Con git log ya sabes responder a “¿qué he hecho hasta ahora?”. Ese es el primer superpoder que te da Git: la memoria de tu proyecto siempre está ahí, ordenada y consultable. Su pareja natural es git status, que en lugar del pasado te enseña el presente (qué tienes pendiente de guardar ahora mismo); lo explico en entender la salida de git status.

A partir de aquí se abren caminos que vale la pena conocer. Con los hashes que ves en el log puedes viajar a un commit antiguo para inspeccionar cómo estaba el proyecto en aquel momento, y también pedirle a Git que te enseñe exactamente qué cambió entre dos puntos de la historia. Pero eso ya toca ver el contenido de los cambios, no solo su lista, y para eso hay comandos específicos que merecen su propio hueco.

De momento quédate con lo esencial: escribes git log --oneline, ves tu historia de un vistazo, y sales con q. Con eso ya no te vas a volver a quedar atrapada en esa pantalla verde.

Si quieres coger soltura de verdad con estos comandos, practicándolos sobre repositorios reales en lugar de solo leerlos, el curso Git de cero a profesional te lleva paso a paso desde el primer commit hasta moverte por el historial con confianza.

Preguntas Frecuentes

¿Cómo salgo de git log cuando se me llena la pantalla y no responde?

Pulsa la tecla q. Cuando el historial no cabe en pantalla, git log lo abre en un pager llamado less, que espera a que navegues con las flechas o la barra espaciadora. La terminal no está colgada: solo está esperando. La tecla q (de quit) cierra el visor y te devuelve al terminal normal.

¿git log muestra los cambios de cada línea de código?

No. git log te enseña la lista de commits con su hash, autor, fecha y mensaje, pero no el contenido concreto de lo que cambió dentro de cada uno. Para ver qué líneas se añadieron o se borraron necesitas git diff, que es un comando distinto pensado justo para eso.

¿Qué diferencia hay entre el hash largo y el hash corto?

Son el mismo identificador, solo que con distinta longitud. El hash completo tiene 40 caracteres hexadecimales y es lo que Git guarda internamente. El hash corto son los primeros 7 caracteres, que Git muestra en git log --oneline porque casi siempre bastan para distinguir un commit de otro. Puedes usar el corto en la mayoría de comandos sin problema.

¿Puedo ver solo mis propios commits?

Sí, con la opción --author seguida de parte de tu nombre o tu email, por ejemplo git log --author="sofia" --oneline. Git filtra el historial y te muestra únicamente los commits cuyo autor coincide con ese texto. Es muy práctico en un proyecto compartido donde varias personas van dejando commits mezclados.

¿Qué es HEAD exactamente?

HEAD es un puntero que marca en qué commit estás situada ahora mismo, el commit sobre el que trabajas. Piénsalo como el marcapáginas de tu proyecto: normalmente apunta al último commit de tu rama actual, y cuando haces un commit nuevo, HEAD avanza para señalarlo. En la salida de git log aparece arriba del todo, como HEAD -> main.

Un concepto nuevo cada semana

Suscribirme