0Pricing
Git & GitHub Professional Workflow · Lección

Git Bisect para depuración

Utilice `git bisect` para encontrar eficazmente el commit específico que introdujo un error y ahorrar tiempo de depuración.

Git Bisect para depuración es una lección gratuita de Git & GitHub Professional Workflow en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Git & GitHub Professional Workflow, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Git & GitHub Professional Workflow incluye 4 lecciones en total.

Encuentre errores más rápido con Git

Depurar puede ser difícil. A veces aparece un error y no sabe qué cambio lo provocó.

git bisect es un potente comando de Git que le ayuda a localizar el commit exacto que introdujo un error. Utiliza un algoritmo de búsqueda binaria para acotar rápidamente miles de commits.

El poder de la búsqueda binaria

Imagine que su proyecto tiene 100 commits y que el error apareció en algún punto entre el primero y el último. ¡Comprobarlos uno por uno manualmente es lento!

git bisect funciona como un juego de «adivinar el número»:

  • Indica a Git un commit «bueno» (en el que no estaba presente el error).
  • Indica a Git un commit «malo» (en el que sí está presente el error).
  • Git selecciona un commit aproximadamente intermedio y le pide que lo pruebe.
  • Lo marca como «bueno» o «malo» y Git reduce a la mitad el espacio de búsqueda.

¡Comencemos la búsqueda!

Para empezar, debe indicar a Git que va a iniciar una sesión de bisect. Este comando inicializa el proceso:

git bisect start

Después de iniciarla, especificará un commit «malo» conocido (en el que existe el error) y un commit «bueno» conocido (en el que el error no existía con certeza).

A menudo, el commit «malo» es su HEAD actual, y un commit «bueno» puede ser una etiqueta de una versión anterior o un commit de hace unos días.

Marcar los límites de los commits

Una vez iniciado git bisect, defina el intervalo de búsqueda:

  • Commit malo: Es un commit en el que sabe que existe el error. Utilice git bisect bad <commit-hash> o simplemente git bisect bad si se trata de su HEAD actual.
  • Commit bueno: Es un commit en el que sabe que NO existía el error. Utilice git bisect good <commit-hash>.

Git cambiará automáticamente a un commit situado en el centro de este intervalo.

Probar y acotar la búsqueda

Después de marcar los commits buenos y malos, Git cambiará automáticamente a un commit situado en el centro del intervalo. Su tarea consiste en probar el código en ese commit.

  • Si el error ESTÁ presente, escriba git bisect bad.
  • Si el error NO está presente, escriba git bisect good.

Git elegirá otro commit intermedio del intervalo restante. Repita el proceso hasta que Git encuentre el primer commit «malo».

Simular la introducción de un error

Imaginemos un «error» sencillo en un script. Simularemos el historial de un proyecto en el que se introdujo un pequeño fallo.

Este es nuestro script inicial «bueno»:

main.sh

#!/bin/bash
echo "Hello from script!"
sum=0
for i in $(seq 1 3); do
  sum=$((sum + i))
done
echo "Sum is: $sum"

Guía práctica del bisect manual

Ahora supongamos que un commit posterior cambió accidentalmente el bucle a seq 1 4, lo que hace que la suma sea incorrecta (10 en lugar de 6).

Comenzaríamos con:

git bisect start

Después marcaríamos nuestro HEAD actual (donde existe el error) como malo:

git bisect bad HEAD

Y un commit antiguo que sabemos que funcionaba como bueno:

git bisect good <old_good_commit_hash>

Git le guiará cambiando a distintos commits. Ejecutaría ./main.sh, comprobaría si la suma es 6 o 10 y, después, escribiría git bisect good o git bisect bad, según corresponda.

Automatizar el proceso de depuración

Probar cada commit manualmente puede llevar mucho tiempo si la prueba es compleja. ¡git bisect run le permite automatizar este proceso!

Debe proporcionar un script que finalice con:

  • 0 (cero) si el commit es bueno.
  • 125 si se debe omitir el commit.
  • Cualquier otro valor distinto de cero (por ejemplo, 1) si el commit es malo.

Git ejecutará este script en cada commit probado hasta encontrar el error.

#!/bin/bash
./main.sh | grep "Sum is: 6"
if [ $? -eq 0 ]; then
  exit 0 # Good commit
else
  exit 1 # Bad commit
fi

Finalizar la búsqueda

Cuando git bisect identifica correctamente el primer commit malo, le mostrará el hash y el mensaje del commit.

Después de encontrar al responsable y comprender el problema, es fundamental devolver el repositorio a su estado original, anterior al inicio del bisect:

git bisect reset

Este comando le devuelve al commit en el que se encontraba cuando inició el bisect y limpia su estado temporal.

Comprobación de conocimientos sobre Bisect

Acaba de ejecutar git bisect start, ha marcado su HEAD actual como malo y un commit antiguo como bueno. Git cambia a un commit intermedio.

Ejecuta las pruebas y el error ESTÁ PRESENTE en este commit intermedio.

Resumen de `git bisect`

¡Enhorabuena! Ha aprendido a utilizar git bisect:

  • Es una herramienta potente para encontrar el commit exacto que introdujo un error.
  • Utiliza una búsqueda binaria para mejorar la eficiencia.
  • Define commits «buenos» (sin errores) y «malos» (con errores).
  • Puede automatizar el proceso de pruebas con git bisect run <script>.
  • ¡Recuerde ejecutar siempre git bisect reset para limpiar todo al terminar la búsqueda!

Preguntas frecuentes

¿La lección «Git Bisect para depuración» es gratis?

Sí — el texto completo de «Git Bisect para depuración» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Git & GitHub Professional Workflow, actualiza a CoddyKit PRO. El curso de Git & GitHub Professional Workflow incluye 4 lecciones en total.

¿Qué aprenderé en «Git Bisect para depuración»?

Utilice `git bisect` para encontrar eficazmente el commit específico que introdujo un error y ahorrar tiempo de depuración. Practicas Git & GitHub Professional Workflow con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Git & GitHub Professional Workflow?

No se requiere experiencia previa. Git & GitHub Professional Workflow en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Git Bisect para depuración»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Git & GitHub Professional Workflow?

Sí. Cada lección de Git & GitHub Professional Workflow incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Git Reflog y recuperación del historial
  2. Git Bisect para depuración
  3. Mantenimiento y limpieza de repositorios
  4. Reescritura del historial con git filter-repo
← Volver a Git & GitHub Professional Workflow