Git
Halvera / hitta felaktiga åtaganden

Syntax

• git bisect <subcommand> <options>

• git bisect start <bad> [<good>...]

• git bisect reset

• git bisect good

• git bisect bad

Binär sökning (git bisect)

git bisect låter dig hitta vilket engagemang som introducerade ett fel med en binär sökning.

Börja med att halvera en session genom att ange två åtkomstreferenser: ett bra åtagande före felet och ett dåligt åtagande efter felet. Generellt sett är det dåliga engagemanget HEAD .

# start the git bisect session
$ git bisect start

# give a commit where the bug doesn't exist
$ git bisect good 49c747d

# give a commit where the bug exist
$ git bisect bad HEAD

git startar en binär sökning: Den delar upp revisionen i hälften och växlar förvaret till mellanversionen. Kontrollera koden för att avgöra om revisionen är bra eller dålig:

# tell git the revision is good,
# which means it doesn't contain the bug
$ git bisect good

# if the revision contains the bug,
# then tell git it's bad
$ git bisect bad

git fortsätter att köra den binära sökningen på varje återstående delmängd av dåliga revisioner beroende på dina instruktioner. git kommer att presentera en enda revision som, om inte dina flaggor var felaktiga, kommer att representera exakt revisionen där felet introducerades.

Kom sedan ihåg att köra git bisect reset att avsluta bisekt-sessionen och återgå till HEAD.

$ git bisect reset

Om du har ett skript som kan leta efter felet kan du automatisera processen med:

$ git bisect run [script] [arguments]

Där [script] är sökvägen till ditt skript och [arguments] är alla argument som bör skickas till ditt skript.

Att köra detta kommando körs automatiskt genom den binära sökningen, exekverar git bisect good eller git bisect bad i varje steg beroende på utgångskoden för ditt skript. Att avsluta med 0 indikerar good , medan avresa med 1-124, 126 eller 127 indikerar dåligt. 125 indikerar att skriptet inte kan testa den revisionen (vilket kommer att utlösa en git bisect skip ).

Halvautomatiskt hitta ett felaktigt åtagande

Föreställ dig att du är i master och något fungerar inte som förväntat (en regression infördes), men du vet inte var. Allt du vet är att det fungerade i den senaste utgåvan (som t.ex. var taggad eller om du känner till åtagandets hash, låt oss ta old-rel här).

Git har hjälp för dig, att hitta felaktiga begåvningar som introducerade regressionen med ett mycket lågt antal steg (binär sökning).

Börja först med att halvera:

git bisect start master old-rel

Detta kommer att säga git att master är en trasig revision (eller den första trasiga versionen) och old-rel är den senaste kända versionen.

Git kommer nu att kolla in ett fristående huvud mitt i båda åtagandena. Nu kan du göra dina tester. Beroende på om det fungerar eller inte

git bisect good

eller

git bisect bad

. Om detta åtagande inte kan testas, kan du enkelt git reset och testa att en, git willl tar hand om detta.

Efter några steg kommer git att mata ut det felaktiga engagemanget.

För att avbryta bisektprocessen bara fråga

git bisect reset

och git återställer det tidigare tillståndet.