Introduktion till Git Interactive Rebase

Det här inlägget kommer kortfattat att förklara introduktionen till Git interaktiv rebase.

Introduktion till Git Interactive Rebase

Git interaktiv rebase är ett kraftfullt verktyg för att hantera commits i ett Git-förråd. Det tillåter utvecklare/användare att ändra, ordna om eller ta bort commits i en filials historia. En interaktiv rebase är särskilt användbar när utvecklare måste rensa upp en gren innan den slås samman till en annan gren eller när de vill göra ändringar i tidigare commits.

Hur fungerar Git Interactive Rebase?

För att börja arbeta med den interaktiva Git-rebasen kan användaren utföra flera ändringar som anges nedan:

• Beställ om beställer
• Fusion åtar sig
• Ändra åtaganden
• Ta bort Commits

Beställ om beställer

För att ordna om commits, prova nedanstående procedur:

• Gå till det lokala Git-förrådet.
• Kontrollera Git-loggen.
• Ändra ordningen på bekräftelserna manuellt och verifiera ändringarna.

Steg 1: Navigera till Local Repository

Till en början, navigera till det lokala Git-förrådet genom att ange sökvägen med hjälp av ' CD ” kommando:

Steg 2: Kontrollera Git Log

Se hela Git-loggen med hjälp av ' git log –oneline ”. Det kommer att visa varje commit på en enda rad:

Som ett resultat visas alla commits på Git Bash-terminalen:

Steg 3: Beställ om

Kör nu ' git rebase -i ' kommando där ' -jag ' används för interaktivt läge, och ' HUVUD~3 ” kommer att välja tre commits från Git-loggen:

Den resulterande bilden visar som ersätter positionen för alla commits i de öppna redigerarna:

Bilden nedan visar att commits har ersatts med varandra manuellt:

Slutligen har åtagandena framgångsrikt återbaserats med hjälp av ' git rebase -i ”.

Steg 4: Verifiera ändringar

Verifiera ändringarna genom att utföra det givna kommandot:

Det kan noteras att de valda commits har omordnats framgångsrikt:

Fusion åtar sig

För att slå samman två eller flera åtaganden, följ instruktionerna:

• Se Git-loggen.
• Använd ' git rebase -i HEAD~3 ” kommando för att slå samman commits i en enda commit.
• Ersätt ' plocka ' nyckelord med ' squash ' att sammanföra.

Steg 1: Kontrollera Git Log

Se först den fullständiga historiken för Git-loggen genom att utföra kommandot nedan.

Den angivna bilden visade resultatet av kommandot ovan:

Steg 2: Merge Commits

Slå nu samman commits genom att använda ' git rebase -i ” kommando. den ' HUVUD~3 ” används för att välja de tre commits och öppna den angivna editorn:

Som ett resultat har editorn öppnats:

Steg 2: Ersätt 'plocka' med 'squash'

Ersätt ' plocka 'ord med ' squash ” som används för att slå samman commits i den första och spara ändringarna:

Steg 3: Bekräfta ändringar

Då kommer en ny editor upp på skärmen. Här skriver du ett commit-meddelande för att bekräfta ändringarna och spara det genom att trycka på ' Ctrl+s ”:

Det kan noteras att alla ändringar har genomförts framgångsrikt:

Steg 4: Verifiering

Verifiera ändringarna ovan med hjälp av det nämnda kommandot:

Det kan noteras att alla valda commits har slagits samman framgångsrikt:

Ta bort Commits

För att ta bort commits från Git-loggens historia, prova det angivna steget som nämns nedan:

• Visa Git-logghistorik.
• Ta bort en commit manuellt från redigeraren.
• Verifiera genom att se Git-logghistoriken.

Steg 1: Kontrollera Git Log History

Kör det givna kommandot för att kontrollera Git-loggen. den ' git log –oneline kommandot används för att visa varje commit på en enda rad:

Den givna bilden visar hela Git-logghistoriken:

Steg 2: Ta bort Commit

Öppna redigeraren genom att använda ' git rebase -i kommandot tillsammans med ' HUVUD~2 ” för att välja två commits från logghistoriken:

Välj en commit och ta bort den manuellt från redigeraren:

Ta här bort den valda commit från redigeraren och tryck på ' Ctrl+s ”-tangenter för att spara ändringarna:

Den resulterande bilden indikerar att ombasoperationen har utförts framgångsrikt:

Steg 3: Verifiering

Kör kommandot nedan för verifieringsändamål:

Den valda commit har tagits bort från logghistoriken:

Det handlar om den interaktiva Git-rebasen.

Slutsats

Git interaktiv rebase är den mest kraftfulla operationen för att hantera commits i ett Git-förråd. Det tillåter utvecklare/användare att ändra, ordna om eller ta bort commits i en filials historik med hjälp av ' git rebase -i ” kommando. Dessutom kan den också användas för att rensa Git-historiken genom att slå samman alla commits i en. Det här inlägget har förklarat introduktionen till den interaktiva Git-rebasen.