0Pricing
Git & GitHub Professional Workflow · Lezione

Git Bisect per il debug

Utilizzi `git bisect` per trovare in modo efficiente il commit specifico che ha introdotto un bug, risparmiando tempo prezioso nel debug.

Git Bisect per il debug è una lezione Git & GitHub Professional Workflow gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Git & GitHub Professional Workflow, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Git & GitHub Professional Workflow include 4 lezioni in totale.

Trovare i bug più rapidamente con Git

Il debugging può essere difficile. A volte compare un bug e non si sa quale modifica lo abbia causato.

git bisect è un potente comando Git che aiuta a individuare il commit esatto che ha introdotto un bug. Usa un algoritmo di ricerca binaria per restringere rapidamente il campo tra migliaia di commit.

La potenza della ricerca binaria

Immagini che il progetto abbia 100 commit e che un bug sia comparso in un punto tra il primo e l'ultimo. Controllarli manualmente uno per uno richiede molto tempo!

git bisect funziona come un gioco in cui bisogna «indovinare il numero»:

  • Indica a Git un commit «buono» (in cui il bug non era presente).
  • Indica a Git un commit «cattivo» (in cui il bug è presente).
  • Git sceglie un commit all'incirca a metà e Le chiede di verificarlo.
  • Lo contrassegna come «buono» o «cattivo» e Git dimezza l'intervallo di ricerca.

Iniziamo la ricerca!

Per iniziare, deve comunicare a Git che sta avviando una sessione di bisect. Questo comando inizializza il processo:

git bisect start

Dopo l'avvio, specificherà un commit «cattivo» noto (in cui il bug è presente) e un commit «buono» noto (in cui il bug sicuramente non era presente).

Spesso il commit «cattivo» è il HEAD corrente, mentre un commit «buono» può essere un tag di una release precedente o un commit di qualche giorno prima.

Definire i limiti dei commit

Una volta avviato git bisect, definisca l'intervallo di ricerca:

  • Commit cattivo: è un commit in cui sa che il bug è presente. Usi git bisect bad <commit-hash> oppure semplicemente git bisect bad se si tratta del HEAD corrente.
  • Commit buono: è un commit in cui sa che il bug NON era presente. Usi git bisect good <commit-hash>.

Git eseguirà quindi automaticamente il checkout di un commit al centro di questo intervallo.

Test e restringimento dell'intervallo

Dopo aver contrassegnato i commit buono e cattivo, Git eseguirà automaticamente il checkout di un commit al centro dell'intervallo. Il Suo compito è testare il codice in questo commit.

  • Se il bug È presente, digiti git bisect bad.
  • Se il bug NON è presente, digiti git bisect good.

Git sceglierà quindi un altro commit centrale nell'intervallo rimanente. Ripeta l'operazione finché Git non trova il primo commit «cattivo».

Simulare l'introduzione di un bug

Immaginiamo un semplice «bug» in uno script. Simuleremo la cronologia di un progetto in cui è stato introdotto un piccolo errore.

Ecco il nostro script iniziale «buono»:

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"

Procedura guidata per il bisect manuale

Ora supponiamo che un commit successivo abbia modificato accidentalmente il ciclo in seq 1 4, rendendo errata la somma (10 invece di 6).

Inizieremmo con:

git bisect start

Poi contrassegneremmo il HEAD corrente (in cui il bug è presente) come cattivo:

git bisect bad HEAD

E un commit precedente, sicuramente funzionante, come buono:

git bisect good <old_good_commit_hash>

Git La guiderà quindi eseguendo il checkout dei commit. Dovrà eseguire ./main.sh, verificare se la somma è 6 o 10 e digitare di conseguenza git bisect good o git bisect bad.

Automatizzare il processo di debugging

Testare manualmente ogni commit può richiedere comunque molto tempo se il test è complesso. git bisect run consente di automatizzare questa operazione!

Fornisca uno script che restituisca:

  • 0 (zero) se il commit è buono.
  • 125 se il commit deve essere ignorato.
  • Qualsiasi altro valore diverso da zero (ad esempio 1) se il commit è cattivo.

Git eseguirà lo script su ogni commit testato finché non troverà il bug.

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

Concludere la ricerca

Quando git bisect identifica correttamente il primo commit cattivo, mostrerà l'hash e il messaggio del commit.

Dopo aver trovato il responsabile e compreso il problema, è fondamentale riportare il repository allo stato originale precedente all'avvio del bisect:

git bisect reset

Questo comando La riporta al commit in cui si trovava quando ha avviato il bisect e rimuove lo stato temporaneo del bisect.

Verifica delle conoscenze sul bisect

Ha appena eseguito git bisect start, contrassegnato il HEAD corrente come cattivo e un commit precedente come buono. Git esegue il checkout di un commit intermedio.

Esegue i test e il bug È PRESENTE in questo commit intermedio.

Riepilogo di `git bisect`

Congratulazioni! Ha imparato a usare git bisect:

  • È uno strumento potente per trovare il commit esatto che ha introdotto un bug.
  • Usa una ricerca binaria per essere efficiente.
  • Definisce commit «buoni» (senza bug) e «cattivi» (con bug).
  • Può automatizzare il processo di test con git bisect run <script>.
  • Ricordi sempre di eseguire git bisect reset per ripulire l'ambiente dopo la ricerca!

Domande Frequenti

La lezione «Git Bisect per il debug» è gratuita?

Sì — il testo completo di «Git Bisect per il debug» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Git & GitHub Professional Workflow, passa a CoddyKit PRO. Il corso Git & GitHub Professional Workflow include 4 lezioni in totale.

Cosa imparerò in «Git Bisect per il debug»?

Utilizzi `git bisect` per trovare in modo efficiente il commit specifico che ha introdotto un bug, risparmiando tempo prezioso nel debug. Eserciti Git & GitHub Professional Workflow con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Git & GitHub Professional Workflow?

Non è richiesta alcuna esperienza precedente. Git & GitHub Professional Workflow su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Git Bisect per il debug»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Git & GitHub Professional Workflow?

Sì. Ogni lezione Git & GitHub Professional Workflow include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Git Reflog e recupero della cronologia
  2. Git Bisect per il debug
  3. Manutenzione e pulizia del repository
  4. Riscrivere la cronologia con git filter-repo
← Torna a Git & GitHub Professional Workflow