Top 20 Git-commando’s met voorbeelden: een praktische gids

Werken met externe repositories

GitHub host diverse applicaties op zijn externe servers, zodat ontwikkelaars ze kunnen bijhouden en beheren. In deze sectie bekijken we hoe je die externe repositories ophaalt, overdraagt en ermee interacteert met Git-commando’s. 

Wil je leren hoe GitHub werkt? Begin met een introductie tot GitHub-concepten om repositories, pull requests en samenwerkingsbest practices te begrijpen.

git remote add

Het commando git remote add legt een verbinding tussen je lokale Git-repository en de externe Git-repository, zodat je wijzigingen ertussen kunt pushen en pullen:

git remote add <repo_name> <remote_url>

• <repo_name>: een bijnaam voor de externe repository (“origin” is standaard).
• <remote_url>: de URL van de externe repository.

git push

Het commando git push synchroniseert je externe repository met de lokale repository. Zodra je dit commando uitvoert, weerspiegelt de externe repository alle wijzigingen die je lokaal hebt gecommit.

git push <remote> <branch>

• <remote>: alias van de externe repository (“origin” is standaard).
• <brach>: naam van de branch die je wilt pushen.

Er zijn enkele varianten van git push, bijvoorbeeld:

git push ---all origin

Bovenstaand commando pusht al je lokale branches naar de externe repository.

git push --force origin main

Bovenstaand commando overschrijft de main-branch op de externe repository met je lokale main-branch. Wees voorzichtig met het gebruik hiervan, want de externe main-branch kan al zijn historie verliezen. 

git pull

Het commando git pull haalt de wijzigingen op uit de externe repository en merge’t ze met die in de lokale repository. 

Het commando git pull combineert twee commando’s: git fetch en git merge. 

Eerst haalt git fetch alle wijzigingen op uit de externe repository, waaronder nieuwe commits, tags en branches. Daarna voert git merge uit, waarmee die wijzigingen in de huidige lokale branch worden geïntegreerd. 

De syntax:

git pull origin feature-branch

Bovenstaand commando haalt data op van de feature_branch op de externe repository en commit die naar je huidige lokale branch. 

git fetch

Het commando git fetch laat je wijzigingen in de externe repository beoordelen voordat je ze in je lokale repository merge’t. Het downloadt de wijzigingen en werkt ze bij in remote-trackingbranches. Voor wie dit niet kent: remote-trackingbranches zijn kopieën van branches in de externe repository. 

Bijvoorbeeld, het volgende commando downloadt de wijzigingen in de externe repository en werkt ze bij in remote-trackingbranches onder origin:

git fetch origin

Branching en mergen in Git

Met Git-branching kunnen ontwikkelaars onafhankelijk werken aan nieuwe features of bugfixes zonder de hoofdrepository te beïnvloeden. Zodra de wijzigingen klaar zijn, integreert mergen ze in de primaire codebase. Laten we de belangrijkste commando’s in dit proces verkennen.

git branch

Het commando git branch toont, maakt of verwijdert branches. Een branch is een andere versie van je repository. 

Als je een nieuwe feature voor je applicatie ontwikkelt, kun je een nieuwe branch aanmaken en daarop werken.Je kunt deze nieuwe branch mergen met de main-branch zodra de wijzigingen klaar en getest zijn. Zo kun je onafhankelijk aan nieuwe features werken zonder direct aan de hoofdversie te zitten. 

• git branch: toont de lijst met alle branches in de repository.
• git branch <branch_name>: maakt een nieuwe branch met de naam “branch_name”.
• git branch -d <branch_name>: verwijdert de branch met de naam “branch_name”.

git checkout

Het git checkout-commando kan twee dingen: schakelen tussen branches of bestanden herstellen naar een vorige staat. 

• Tussen branches wisselen: Vóór git 2.23 werd git checkout branch_name gebruikt om van je huidige branch naar een andere te wisselen. Het was niet alleen voor wisselen: je kon ook een nieuwe branch maken en er meteen naartoe schakelen.

Het volgende commando maakt een nieuwe branch “feature_branch” en schakelt erheen:

git checkout -b feature_branch

In de nieuwste versie van Git is git checkout voor het herstellen van bestanden vervangen door git switch. 

• Bestanden herstellen: Je kunt de wijzigingen in een bestand weggooien en het herstellen naar de vorige versie met het volgende commando.

git checkout -- <file-name>

Je kunt dit ook doen met een bestand uit een andere branch als volgt:

git checkout <branch-name> -- <file-name>

git merge

Als je in een nieuwe branch werk hebt gedaan, kun je die met git merge in de main-branch mergen om de wijzigingen door te voeren. Git voert mergen op twee manieren uit:

• Fast-forward merge: Stel, je maakte een nieuwe branch “feature_x” vanuit main en werkte daarop. Als main geen updates heeft gehad sinds je “feature_x” maakte, dan commit Git niet de “feature_x”-wijzigingen naar main, maar schuift het de verwijzing van main door naar de laatste versie van “feature_x”. Er wordt dan geen nieuwe merge-commit aangemaakt. 
• Three-way merge: Als zowel “feature_x” als main aanpassingen hebben, combineert Git de wijzigingen en maakt het een nieuwe merge-commit op main. 

Bijvoorbeeld: 

      C---D---F (feature-branch)
     /
A---B---E---G (main)

Bij commit B wordt de feature-branch C gemaakt. De main-branch krijgt extra commits, E en G, ook nadat de feature-branch is aangemaakt. Daarom wordt de feature in main gemerged en ontstaat er een nieuwe merge-commit M als volgt:

      C---D---F (feature-branch)
     /         \         
A---B---E---G---M (main)

git rebase

git rebase is een andere manier om wijzigingen tussen branches te integreren, maar werkt anders dan git merge. Merge behoudt de volledige historie van zowel main als de feature-branch. Rebase daarentegen herschrijft de commitgeschiedenis om die lineair en overzichtelijk te maken.

Bovendien vereist mergen een extra merge-commit, terwijl rebase geen nieuwe commits aanmaakt. Git rebase voert twee stappen uit: 

1. Schakel over naar een feature-branch 
2. Rebase naar main.

Bijvoorbeeld:

      C---D---F (feature-branch)
     /
A---B---E---G (main)

• Stap 1: voer git checkout feature_branch uit.
• Stap 2: Voer git rebase main uit: de volledige feature-branch wordt op main gezet door de commits C, D, F opnieuw toe te passen als C’, D’ en F’ boven op de laatste commit G van de main-branch. Dit creëert een lineaire commitgeschiedenis als volgt:

A---B---E---G---C'---D'---F' (main)

Omdat merge- en rebase-bewerkingen vaak worden verward, volgt hier een samenvatting van de verschillen:

Meer leren over werken met externe branches? Leer hoe je externe branches uitcheckt en volgt met git checkout in deze stapsgewijze tutorial.

Git-historie en wijzigingen ongedaan maken

Git biedt verschillende commando’s om de historie te bekijken en wijzigingen ongedaan te maken in verschillende ontwikkelstadia. Relevante commando’s worden hier besproken. 

git log

Het commando git log toont de volledige commitgeschiedenis van je huidige branch. Het bevat vier kernvelden: commit, auteur, datum en commitbericht. 

git commitgeschiedenis

• Commit: een unieke ID.
• Auteur: naam en e-mailadres van de persoon.
• Datum: het tijdstip waarop de wijziging is gecommit.
• Commitbericht: beschrijving van de commit. 

git diff

Het commando git diff toont de verschillen tussen verschillende toestanden van je repository—of je nu je huidige map vergelijkt met de staging area, de staging area met de laatste commit, of zelfs twee bestanden of branches, afhankelijk van wat je opgeeft.

• git diff - toont het verschil tussen je huidige werkmap en de staging area. 
• git diff -- cached: toont de verschillen tussen de staging area en de laatste commit.
• git diff commit1 commit2 - het verschil tussen commit 1 en commit 2.
• git diff branch1..branch2 - vergelijkt de verschillen tussen branch 1 en branch 2.

git reset

Het commando git reset laat je wijzigingen ongedaan maken door de huidige HEAD terug te zetten naar een specifieke eerdere staat. Om de HEAD naar een vorige commit te verplaatsen, heb je drie varianten: “soft”, “mixed” en “hard” om met het reset-commando te gebruiken. 

• Soft: gaat terug naar een eerdere commit maar houdt de huidige wijzigingen gestaged, zodat je ze later opnieuw kunt committen. 

git reset --soft HEAD~1

• Mixed: gaat terug naar een eerdere commit en verwijdert de wijzigingen van de huidige commit uit de staging area. Die wijzigingen blijven echter wel in je werkmap staan.

git reset --mixed HEAD~1

• Hard: wijst naar een eerdere commit en verwijdert de updates van de huidige commit uit zowel de werkmap als de staging area. 

git reset --hard HEAD~1

Wil je wijzigingen in Git ongedaan maken? Verken de verschillen tussen git reset en git revert in deze gedetailleerde gids.

Git stashing en opruimen

Tijdens het werken met Git wil je soms wijzigingen tijdelijk opzijzetten zonder ze te committen, of overbodige bestanden opruimen die je repository vervuilen. Dan komen Git-stash- en opruimcommando’s van pas.

git stash

Stel dat je naar een vorige staat wilt terugkeren, maar je huidige voortgang niet wilt committen; dan kun je git stash gebruiken. Dit slaat je niet-gecommitete wijzigingen tijdelijk op en zet je werkmap terug naar de laatst gecommitete staat. 

git stash pop

Als je eerder wijzigingen hebt gestasht en die weer in je werkmap wilt opnemen, gebruik je het commando git stash pop. Dit past de laatst gestashte wijzigingen toe op de huidige map en verwijdert ze uit de stashlijst. 

git clean

Het commando git clean verwijdert ongetrackte bestanden uit de Git-repository. Gebruik het commando git clean -n om te bekijken wat er verwijderd zal worden voordat je daadwerkelijk opruimt!

Je Git-historie opschonen? Leer hoe je meerdere commits samenvoegt tot één met deze Git squash-tutorial.

Git-configuratie en gebruikersinstellingen

Git laat je gebruikersinstellingen op verschillende niveaus configureren. Laten we die hier bekijken.

git config

Met het commando git config kun je Git-instellingen naar wens aanpassen. Je kunt instellingen configureren op drie niveaus: lokaal, systeem en globaal. 

• Systeemniveau: Dit is het breedste configuratieniveau met root-toegang.
• Globaal niveau: configuraties op dit niveau gelden voor alle repositories voor de huidige gebruiker. 
• Lokaal niveau: instellingen die relevant zijn voor de huidige Git-repository kunnen op dit niveau worden aangepast. 

Dit zijn enkele veelgebruikte git config-commando’s:

• git config -list: toont Git-instellingen van alle niveaus.
• git config --global user.name "Your_name": stelt de Git-gebruikersnaam voor alle repositories op je systeem in op “Your_name”.
• git config --global user.email "your.email@example.com": stelt het e-mailadres in voor alle repositories op je systeem.

We weten dat master de standaard main-branch is bij het initialiseren van een Git-repository. Maar je kunt die hernoemen naar wat je wilt met het volgende commando:

git config --global init.defaultBranch "srujana_master"

In het bovenstaande commando hebben we de standaard master-branch op globaal niveau (voor alle repositories op het systeem) vervangen door "srujana_master".

Je kunt ook andere globale instellingen toepassen. Bijvoorbeeld, om je standaard teksteditor te wijzigen naar VS Code, voer je het volgende commando uit:

git config -global core.editor "code-w"

Je kunt ook je eigen Git-commando’s maken. Bijvoorbeeld:

git config --global alias.slice branch

Bovenstaand commando maakt een nieuw alias slice voor branch. Dus als je een nieuwe branch wilt maken, kun je git slice branch_name uitvoeren in plaats van git branch branch_name.

Samenvatting van Git-commando’s

Hier is een samenvatting van de Git-commando’s die we hebben behandeld, handig om bij de hand te houden:

Best practices voor het gebruik van Git

Git effectief gebruiken gaat verder dan alleen wijzigingen bijhouden—het draait om een schone, gestructureerde en collaboratieve workflow. Door best practices te volgen, blijft je repository georganiseerd, is je commitgeschiedenis betekenisvol en verloopt je ontwikkelproces soepel.

Hier zijn een paar goede gewoontes om aan te leren wanneer je met Git werkt:

• Vaak committen: Een van de hoofddoelen van versiebeheer zoals Git is om wijzigingen in de tijd effectief bij te houden. Als je elke wijziging apart commit in plaats van veel wijzigingen tegelijk, is het later eenvoudiger te begrijpen wat er per commit is aangepast. 
• Commit met duidelijke berichten: Koppel elke commit aan een duidelijke boodschap die beschrijft waar die commit over gaat. De volgende keer dat je commits bekijkt, is het veel eenvoudiger te zien welke wijzigingen elke commit heeft aangebracht. 
• Gebruik branches: Maak voor elke nieuwe feature of bugfix een branch, werk daarop en merge die. Dit is de beste manier om nieuw ontwikkelwerk te scheiden van het hoofdproject. 
• Gebruik .gitignore: Een .gitignore-bestand bevat projectbestanden en -mappen die je niet hoeft te tracken. Dit zijn meestal automatisch gegenereerde bestanden, build-artifacts, log-, tijdelijke en platformspecifieke bestanden. Ze negeren voorkomt onnodige logs en versiehistorie, en houdt je geschiedenis schoon.

Conclusie

Git is een krachtige tool voor het bijhouden van wijzigingen, samenwerken met anderen en het onderhouden van een goed gestructureerde ontwikkelworkflow. In dit artikel heb ik essentiële Git-commando’s en best practices behandeld om je te helpen je projecten effectiever te beheren.

Er valt natuurlijk altijd meer te leren! Ben je net begonnen, bekijk dan Introduction to Git om een stevige basis op te bouwen. Wil je je vaardigheden verder aanscherpen, dan gaat Intermediate Git dieper in op geavanceerde workflows en technieken.

Snel een Git-naslag nodig voor toekomstige projecten? Houd essentiële commando’s bij de hand met deze Git-cheat sheet!