Als ontwikkelaar gebruik je waarschijnlijk dagelijks de Git CLI (Command Line Interface). Het herhaaldelijk schrijven van dezelfde oude commando’s kan echter arbeidsintensief zijn, vooral wanneer de commando’s lang zijn. Hier komen Git-aliassen van pas.

In dit artikel leer je hoe je je Git-commando’s kunt vereenvoudigen door aliassen te gebruiken.

Inhoudsopgave

Vereisten

  • Kennis van Git.

  • Git Bash geïnstalleerd (optioneel maar aanbevolen voor Windows-gebruikers).

  • Een IDE zoals VS Code (dit is ook optioneel).

Wat Zijn Git Aliassen?

Git-aliassen zijn aangepaste snelkoppelingen voor bestaande Git-opdrachten, waardoor veelvoorkomende taken sneller en gemakkelijker worden. Ze laten je je eigen opdrachten definiëren, waardoor je snelkoppelingen precies kunt aanpassen naar jouw wensen.

Je hebt twee hoofdopties om git-aliassen toe te voegen/maken in je git-configuratie, door je Git-configuratiebestand te gebruiken of ze rechtstreeks toe te voegen via de CLI (terminal/opdrachtregel).

Deze optie houdt in dat je je globale git-configuratiebestand opent en je git-aliassen onderaan het bestand toevoegt.

Hoe Je Voorkeurs-Git-Editor Instellen

Stel uw standaard Git-configuratie-editor software in, bijvoorbeeld, ik gebruik VS Code om mijn Git-configuratiebestand te bewerken, maar u kunt elke teksteditor/code-editor gebruiken die u verkiest.

Voer dit commando uit om Kladblok als uw voorkeurseditor op Windows (CMD/PowerShell) in te stellen:

git config --global core.editor "notepad"

Voer dit commando uit om VS Code als uw voorkeurseditor op Windows & MacOS /Linux in te stellen:

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

Om een andere standaardeditor in te stellen, zoek online naar “Stel {editor} in als standaard Git-editor,” en vervang {editor} door uw favoriete app.

Hoe het Git-configuratiebestand te openen

Open uw favoriete terminal en voer het volgende commando in. Dit opent het globale Git-configuratiebestand (git config —global), in de bewerkingsmodus (-e).

git config --global -e

U kunt het git-configuratiebestand direct openen vanuit de volgende locaties:

Mac Os: Thuisdirectory → verborgen bestanden tonen (Cmd + Shift + H) → .gitconfig

Windows: C:\Users\YourUsername\ → toon vervolgens verborgen bestanden (in Weergave) → en vind .gitconfig

Linux: Thuisdirectory → verborgen bestanden tonen (Ctrl + H) → .gitconfig

Hoe een Git-alias toe te voegen via uw configuratiebestand

Als u voor de eerste keer Git-aliasen toevoegt, open dan uw .gitconfig bestand, voeg [alias] aan het einde toe en lijst dan uw snelkoppelingen hieronder op. Dit vertelt Git dat dit aliasen zijn. Voeg uw gewenste alias toe (de verkorte opdracht die u wilt uitvoeren).

Het formaat van een git-alias is <alias> = <command>, dus we hebben:

co = checkout
cob = checkout -b

Uitleg van de bovenstaande voorbeelden:

co = checkout dit koppelt het git checkout commando aan een korter git co commando. Je zou dan git co feature/123 in je terminal invoeren.

Je hoeft git niet voor het commando te typen, aangezien de configuratie dit automatisch toevoegt, omdat het weet dat het commando dat je aan het koppelen bent een Git-commando is.

Opmerking: Alle parameters die aan het commando worden doorgegeven, worden alleen toegepast op het uiteindelijke commando dat binnen de alias wordt aangeroepen.

Meer aliassen kunnen op deze manier worden toegevoegd, waarbij snelkoppelingen worden gekoppeld aan bestaande git-commando’s. Het opslaan en sluiten van het bestand maakt de aliassen beschikbaar in je terminal.

Hoe aliassen toe te voegen in de CLI

Als je een meer gestroomlijnde aanpak wilt voor het toevoegen van Git-aliassen, kun je ze rechtstreeks vanuit de terminal/opdrachtregel toevoegen.

Neem de bovenstaande voorbeelden, we kunnen deze rechtstreeks op de volgende manier toevoegen:

Het formaat van het commando is: git config --global alias.{alias} "{origineel commando}":

git config --global alias.co "checkout"
#of
git config --global alias.cob "checkout -b"

Het is zo eenvoudig als dat!

Hoe aangepaste commando’s te maken voor complexere snelkoppelingen

Oké, dit lijkt geweldig, maar het is eigenlijk niet zo indrukwekkend – we verwijderen alleen een paar tekens. We kunnen ze echter veel nuttiger maken, we kunnen onze commando’s maken met behulp van shell-commando’s.

Laten we het volgende voorbeeld nemen, een commando dat ik vaak gebruik!

new-work = !git checkout main && git pull && git cob

Deze alias combineert meerdere Git-opdrachten in één shell-opdracht. Het ! teken vertelt Git om het als een shell-opdracht te behandelen, en niet als een standaard Git-opdracht.

Zonder ! beschouwt Git de alias als een Git-opdracht (bijvoorbeeld, checkout wordt git checkout). Met ! weet Git dat het als een shell-opdracht moet worden uitgevoerd zonder git ervoor te zetten.

Door deze opdrachten te koppelen, kunnen we veel nuttigere aliassen schrijven. De bovenstaande zal:

  • Eerst de main branch uitchecken.

  • Met de && operator betekent het dat de andere opdrachten alleen worden uitgevoerd als de vorige succesvol was.

  • Ten tweede, zal het de wijzigingen van main ophalen.

  • Ten slotte, maak een nieuwe branch aan vanaf de main branch met behulp van onze andere alias git cob.

De uiteindelijke opdracht kan vervolgens parameters accepteren (zoals de originele Git-opdracht zou doen), zodat het als volgt kan worden gebruikt:

git new-work 'feature/new-work-from-main'

Hoe parameters te gebruiken in alle opdrachten

Tot nu toe konden we alleen onze parameters doorgeven aan het uiteindelijke git-commando in onze alias. Maar wat als we parameters willen doorgeven aan enkele, zo niet alle, commando’s binnen de alias? Dit kunnen we bereiken door een shellfunctie te gebruiken.

Neem het volgende voorbeeld:

new-work = "!f() { git checkout \"$1\" && git pull && git checkout -b \"$2\"; }; f"

Hierboven gebruiken we een shellfunctie die invoerparameters verwerkt.

Uitleg:

  1. !f():

    • De ! vertelt Git dat de alias als een shellcommando moet worden geïnterpreteerd in plaats van een standaard Git-commando.

    • f() definieert een shellfunctie f waarmee we meerdere commando’s in sequentie kunnen uitvoeren.

  2. Alles binnen { } wordt uitgevoerd binnen de functie f().

  3. git checkout \”$1”'\: Voert een geparameteriseerde Git-opdracht uit, waarbij $1 is ontsnapt en zal worden vervangen door de 1e parameter die aan de alias is doorgegeven. De \" ontsnappingssequenties rond $1 staan namen van branches met spaties toe.

  4. && is een logische operator die ervoor zorgt dat elke opdracht alleen wordt uitgevoerd als de vorige slaagt. Als git checkout "$1" faalt, worden de daaropvolgende opdrachten niet uitgevoerd.

  5. git checkout -b \”$2”\: Maakt een nieuwe branch met de naam van de tweede parameter zoals eerder.

  6. ;: Markeert het einde van de f() functie;

  7. f: De uiteindelijke f roept de aliasfunctie onmiddellijk aan, wat betekent dat wanneer je de alias aanroept, deze de functie declareert en deze vervolgens onmiddellijk aanroept.

Gebruik:

git new-work development task/feat-123

Andere Nuttige Aliassen

[alias]
     co = checkout
    cob = checkout -b
    s = status
    tidy-up = !git checkout main && git branch | grep -v "main" | xargs git branch -D
    latest = !git checkout main && git pull
    new-work = "!f() { git checkout \"$1\" && git pull && git checkout -b \"$2\"; }; f"
    done = !git push -u origin HEAD
    save = !git add -A && git commit
    saveM = !git add -A && git commit -m
    br = branch --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(contents:subject) %(color:green)(%(committerdate:relative)) [%(authorname)]' --sort=-committerdate

Samenvatting

co: Checkout gegeven tak → git co task/feat-123

cob: Maakt een nieuwe tak aan vanuit de huidige tak → git cob feature/123

s: Roept git status aan om de status van de huidige git-tak te bekijken → git s

tidy-up: Verwijdert alle lokale takken behalve main → git tidy-up

latest: Haalt de laatste wijzigingen op van de externe main tak → git latest

new-work: Maakt een nieuwe tak (2e parameter) aan vanuit de 1e parameter tak → git new-work main feat/123

git done: Duwt de huidige tak naar de externe repository (origin) en stelt deze in als de upstream-tak. Dit kan nuttig zijn bij het duwen van je eerste commit en je krijgt de fout:
fatal: De huidige tak heeft geen upstream-tak. Om de huidige tak te duwen en de externe als upstream in te stellen, gebruik git push --set-upstream origin

save: Zal eenvoudigweg alle gewijzigde bestanden toevoegen en committen, waarbij je standaard Git-editor wordt geopend en een commitbericht wordt gevraagd → git save

savem: Zal hetzelfde doen als hierboven, maar in plaats van je editor te openen, kun je een commitbericht inline doorgeven → git savem ‘Taak123: voeg index.html toe

br: Dit lijkt ingewikkeld, maar is niet zo ingewikkeld als het lijkt, maar benadrukt wel de kracht van aliassen. In essentie past het de uitvoerindeling van git branch aan om een gedetailleerde, kleurgecodeerde lijst van branches weer te geven, gesorteerd op de meest recente commitdatum, het zal er voor elke lokaal aanwezige branch ongeveer uitzien zoals hieronder afgebeeld.

Dat was een introductie tot Git-aliassen en enkele nuttige voorbeelden van aliassen die je als starter aan je configuratie kunt toevoegen.

Zoals altijd, als je erover wilt praten of meer wilt horen over toekomstige artikelen, kun je me volgen op Twitter.