Git is een fantastische manier om versiebeheer toe te passen op een codeerproject – zo fantastisch zelfs dat het bijna de verplichte optie is.

Het idee is om dubbele branches van je hoofdrepository te maken, aan de code te werken, en dan de wijzigingen weer samen te voegen met de rest. Dit betekent dat je veel oude branches in je repo hebt. Hoewel de bestandsgrootte hiervan vaak klein is, zul je toch een git delete willen uitvoeren op een lokale branch om de boel netjes te houden.

Het goede nieuws is dat dit niet veel moeite kost om uit te voeren. Je zult echter moeten overwegen wat de beste aanpak is, afhankelijk van of je de wijzigingen samenvoegt, en wat je moet doen als je een fout krijgt tijdens het verwijderen. Misschien moet je zelfs een verwijderde branch herstellen. Elk van deze scenario’s vereist verschillende vaardigheden en commando’s.

In deze tutorial laten we je zien hoe je een git delete uitvoert op een lokale branch. Maar eerst gaan we het hebben over enkele redenen waarom je lokale branches in Git zou willen verwijderen.

Wat is een Git branch?

Git repositories zijn een verzameling branches – duplicaten van de kerncode erin. In feite kun je geen werkende Git repo hebben zonder een branch.

Vaak zul je een primaire repo hebben (veelgebruikte namen zijn “main” en “trunk”). Deze bevat werkende productiecode die je niet wilt bewerken. In plaats daarvan maak je een duplicaat branch aan van de hoofdrepo, en voer je de benodigde wijzigingen door binnen je branch. Als het tijd is om die wijzigingen samen te voegen met de kerncode, controleer je ze en voeg je ze samen.

Branches laten iedereen in een team samenwerken aan hetzelfde project, onafhankelijk van elkaar. Er is ook geen gevaar dat je een wijziging aanbrengt in werkende code of in de tussentijd op andere wijzigingen stapt.

Je zult echter ook een git delete moeten uitvoeren op een lokale branch. Dit zal een actie voor je zijn die je geregeld zal uitvoeren, en er zijn een aantal solide redenen om dat te doen.

Waarom branches verwijderen in Git?

Je productiecode zal in de hoofdbranch staan. Dit is de enige branch die enige permanentie heeft.

Daarentegen zal bijna elke andere branch die je maakt een tijdelijke houdbaarheid hebben. Als je je werk af hebt, zul je de wijzigingen vastleggen, en dan kijken of je ze kunt samenvoegen met de hoofdbranch, mogelijk in een online repo zoals GitHub.

Dit betekent dat je vaak veel branches tegelijk open hebt staan, afhankelijk van het project en het team. Maar zodra je de samenvoeging hebt afgerond, verdwijnen die branches niet.

Daarom zijn er een paar redenen waarom je een lokale Git branch zou willen verwijderen:

  • Algemene huishouding: Als je thuis klaar bent met koken, was je het keukengerei en berg je het op. Hetzelfde geldt voor het werken met een Git repo: Als je klaar bent met je werk, voeg je wijzigingen samen en verwijder je alle branches die je niet meer nodig hebt. Dit maakt je project en repo ook gemakkelijker te navigeren.
  • Grootte van het archiefbestand: Hoewel Git repo’s vaak klein genoeg zijn om inconsequent te zijn voor de grootte van een project, moet je ze toch in de gaten houden. Een manier om de grootte van een repo te verkleinen is het verwijderen van branches die je niet nodig hebt.
  • Potentiële prestaties: Zelfs als je kerncode goed presteert, doet een branch dat misschien niet, gezien het feit dat je eraan werkt. Daarom zul je open branches tot een minimum willen beperken. Anders zou het slechte prestaties voor je team kunnen betekenen totdat je een project faseert en aanpast.

Zoals je later zult zien is het uitvoeren van een git delete op een lokale branch grotendeels eenvoudig. Het is echter een goed idee om te begrijpen wat er onder de motorkap gebeurt bij het gebruik van dit commando, omdat het niet alles met betrekking tot de branch uit je repo verwijdert.

Wat gebeurt er als je een lokale Git branch verwijdert?

Op een technisch niveau is een branch slechts een verwijzing naar een specifieke commit – een deel van de code dat je in je hoofdbranch wilt opnemen. Daarom zullen de commits nog steeds blijven bestaan als je een lokale Git branch verwijdert,.

Later zullen we het hebben over branchherstel, en wat er mogelijk is doordat die commits in je repo achterblijven. Voor nu, begrijp dat er twee verschillende soorten wijzigingen zijn:

  • Samengevoegde (merged) wijzigingen: Zodra je een branch samenvoegt met de hoofdbranch, zal de code zo actueel mogelijk zijn. In technische termen is dit vergelijkbaar met het verplaatsen van de reference van de hoofdbranch zodat deze weer gelijkstaat met je secundaire branch.
  • Niet-samengevoegde (unmerged) wijzigingen: Als je wijzigingen niet samenvoegt, zul je een branch hebben die niet zo actueel is als de hoofdbranch. Als zodanig zal de hoofd branch geen actuele reference commit hebben.

Dit is iets waar we later dieper op in zullen gaan. Laten we het nu eens hebben over wanneer je branches eigenlijk zou willen verwijderen.

Wanneer een “Git Delete” uitvoeren op een lokale branch

Gezien de gevaren van het verwijderen van een branch met niet-samengevoegde wijzigingen, is het belangrijk om geen git delete uit te voeren op een lokale branch totdat je een codemerge uitvoert. Dit zorgt ervoor dat elke branch een actuele reference heeft, en daarmee de meest actuele code.

Het is ook een goed idee om je ervan te verzekeren dat je geen van de commits binnen een tijdelijke branch nodig hebt voordat je een git delete uitvoert. Hoewel je tot op zekere hoogte branches kunt herstellen, is dit werk dat je liever niet uit wil voeren. We zullen je hier later inzicht in geven.

Zo voer je een “Git delete” uit op een lokale branch

In de rest van deze tutorial zullen we je laten zien hoe je een git delete uitvoert op een lokale branch. We zullen het ook hebben over wat te doen met niet-samengevoegde wijzigingen.

Daarna zullen we het hebben over fouten die je zou kunnen zien, en dan hoe je een verwijderde lokale branch kunt herstellen.

Aan het eind kijken we kort naar remote branches en hoe je ook die kunt verwijderen.

Voorwaarden

Git zelf biedt een eenvoudige set commando’s en geeft je veel kracht zonder dat je ooit een boek met lesstof open hoeft te slaan. Toch zijn er een paar verschillende manieren om toegang te krijgen tot een Git repo, afhankelijk van je gekozen app en code-editor.

Hoewel je een “minimale klik” opstelling zou kunnen vinden binnen een speciale grafische gebruikersinterface (GUI) zoals GitKraken of Sublime Merge, gaan we het eenvoudig houden en tools gebruiken die in het besturingssysteem zijn ingebouwd.

Om mee te volgen heb je het volgende nodig:

  • Toegang tot de commandoregel: Onze voorbeelden zullen macOS en iTerm gebruiken. Je kunt echter Cmder voor Windows gebruiken, de standaard Terminal op macOS, hetzelfde op Linux, en meer.
  • Toegang tot je specifieke bestanden: Je zult je projectbestanden op je lokale computer willen hebben, want zonder die bestanden kun je niets doen!
  • Kennis van de commandline: Het zal helpen om enige kennis van de commandline te hebben – specifiek de commando’s om je te helpen door je bestanden te navigeren, samen met enig begrip van hoe de commandoregel werkt.

In werkelijkheid, als je een project hebt met een Git repo en een Terminal venster naar keuze, is dit alles wat je nodig hebt.

Een basic “Git delete” uitvoeren

Allereerst zullen we aannemen dat je een branch met samengevoegde wijzigingen wilt verwijderen. Dit is de meest eenvoudige en meest voorkomende handeling.

Maar misschien wil je eerst git branch -a of git branch --list draaien om alle branches te bekijken en de juiste in je repo te vinden:

Een gedeeltelijk Terminal venster met een macOS gradiënt achtergrond, waarin de gebruiker de huidige branches in een lokaal archief kan zien.
Overzicht van branches in een lokale Git repository.

Hier is het commando dat je nodig hebt om een branch te verwijderen:

git branch -d branch-name

Je zult de specifieke branchnaam willen gebruiken in plaats van onze placeholder.

De flag -d staat hier voor “delete,” en in een kleine lettervorm heb je enige bescherming tegen het verwijderen van een branch met niet-samengevoegde wijzigingen.

Als je een niet-samengevoegde branch probeert te verwijderen, krijg je een foutmelding (of eigenlijk meer een waarschuwing):

Een gedeeltelijk Terminal venster op macOS, met een verloop in de achtergrond. De gebruiker voert een commando uit om een branch te verwijderen, maar er verschijnt een foutmelding:
Proberen een branch te verwijderen met niet-samengevoegde wijzigingen in een Git repository.

Maar je kunt de vlag met een hoofdletter schrijven met -D en deze beschermende waarschuwing overslaan. Hiermee kun je een branch met niet-samengevoegde wijzigingen verwijderen.

Merk op dat je geen bevestiging krijgt om de branch te verwijderen als je de versie met een hoofdletter gebruikt, dus het is een vlag die je voorzichtig wilt gebruiken.

Wat veroorzaakt de “Cannot delete branch” fout?

Omdat het verwijderen van een branch van je repo een grote beslissing is zonder eenvoudige oplossing, geeft Git fouten als je een verkeerde zet doet.

Je zult bijvoorbeeld soms een git delete willen uitvoeren op een lokale branch en een “Cannot delete branch” foutmelding zien:

Een gedeeltelijk Terminal venster met een macOS achtergrond met kleurverloop. De gebruiker maakt een lijst van de huidige branches in de repo, controleert een branch en probeert die vervolgens te verwijderen, wat een fout oplevert. Er staat:
Proberen een branch te verwijderen binnen een Git repo, en een foutmelding zien.

Deze eenvoudige reden ligt bij je huidige locatie binnen de Git repo. Je kunt een branch die je “uitcheckt” niet verwijderen

De oplossing is om naar een andere branch te gaan.

Om deze reden stellen we altijd voor dat je uitcheckt naar de main branch. Op die manier krijg je een foutmelding als je main probeert te verwijderen, en kun je ook elke andere branch in de repo verwijderen.

Zo herstel je een verwijderde lokale Git branch

Gegeven dat een commit blijft bestaan nadat je een lokale branch hebt verwijderd, is er een kleine mogelijkheid om een branch te herstellen nadat je een git delete hebt uitgevoerd. Het is echter omslachtiger dan die wijzigingen eerst samen te voegen. In die situatie weet je dat je een branch niet meer nodig hebt.

Elke commit gebruikt een hashnummer, dat fungeert als zijn referentie. Je kunt die hash gebruiken om uit te checken en een nieuwe branch aan te maken:

Een gedeeltelijk Terminal venster in macOS met een gebruiker die de
Het tonen van zowel korte als lange versies van een reference hash voor een commit in Git.

Maar als je de hash van een verwijderde branch niet weet, kun je het reflog commando gebruiken. Deze “reference logs” lijken veel op die welke je vindt in apps als DevKinsta.

Hoewel het gebruik van git reflog een onderwerp voor een heel ander artikel is, kun je de basisfunctionaliteit gebruiken om de hash van oude commits te vinden. Als je git reflog uitvoert, zie je een lijst met commits:

Een gedeeltelijk Terminal venster in macOS dat de gebruiker laat zien die een "git reflog" commando uitvoert. Het toont een lijst van recente commits, de bijbehorende hashes in geel, de actie die de gebruiker uitvoerde (zoals "checkout" of "commit",) en de specifieke commit beschrijving.
Een Terminal venster dat een git reflog commando uitvoert en de resultaten uitvoert.

De eerste kolom met hashes hier laat je dan de commit uitchecken en een nieuwe branch aanmaken. Bijvoorbeeld:

git checkout 5744ff6
git branch f9d2db5

Dit is echter geen waterdichte manier om een verwijderde branch in Git te herstellen.

In sommige gevallen zal er geen commit in de reflog staan, en geen HEAD verwijzing naar de commit zelf. Daarom is het beter om veiliger met je branches te werken door wijzigingen samen te voegen voordat je een git delete uitvoert op een lokale branch.

Werken met remote Git branches

Als je een git delete uitvoert op een lokale branch, zul je vaak een bijbehorende remote repo hebben. Dit geldt vooral als je je site met Git naar Kinsta pullt.

Deze zal niet samen met je lokale repo worden bijgewerkt als je wijzigingen aanbrengt, en dit geldt ook als je een lokale branch verwijdert.
Maar zowel GitHub als GitLab hebben hetzelfde proces om een remote Git branch te verwijderen. Het is een vergelijkbare aanpak als elke andere “upstream push”.

Hier is het commando:

git push remote-name -d remote-branch

Voor de remote-name, de meeste repo’s die we zien gebruiken “origin.” De remote-branch referentie zal dezelfde zijn als de lokale branch (tenzij je een lokale branch hernoemt, wat buiten het bestek van dit artikel valt)

Even terzijde, je kunt alle branches zien – zowel lokale als remote – met git branch -a. Als je alleen de remote branches wilt zien, kun je git branch -r gebruiken.

Als je het commando hebt uitgevoerd, krijg je een bevestigingsbericht te zien. Op dat moment moet je opnieuw git branch -a uitvoeren om te controleren of alles is verwijderd zoals je had verwacht.

Samenvatting

Git is een van de weinige programma’s die je enorme kracht geeft met behulp van leesbare en intuïtieve commando’s. Dit geldt ook voor het verwijderen van branches die je niet meer nodig hebt op je lokale machine. Je zult echter nog steeds voorzichtig moeten zijn met het uitvoeren van een git delete op een lokale branch.

Dit is omdat als je probeert niet-samengevoegde wijzigingen te verwijderen, je of een foutmelding krijgt, of iets verwijdert dat je toekomstige projectwerk zal beïnvloeden. Bovendien zul je ook de remote branch moeten verwijderen. Zowel je lokale als je remote repos moeten goed bijgehouden worden om de prestaties hoog en de bestandsgrootte minimaal te houden.

Hoewel je er misschien alleen voor staat als je per ongeluk een Git branch verwijdert, heeft Kinsta je gedekt als het gaat om Applicatie Hosting. Het Kinsta hosting platform geeft je de mogelijkheid om in een paar minuten verbinding te maken met je GitHub repo’s en deze te deployen. Bovendien krijg je toegang tot Google’s C2-machines en Premium Tier Network, samen met onze Cloudflare integratie, om je apps naar het volgende niveau qua snelheid en veiligheid te duwen.