Git Init: Hoe een Git-repository initialiseren en opzetten

Heb je ooit per ongeluk een bestand verwijderd of je code overschreven zonder het te kunnen herstellen? Zonder versiebeheer kunnen dergelijke fouten catastrofaal zijn. Daar komt git init om de hoek kijken—het transformeert je projectmap in een Git repository, zodat elke wijziging traceerbaar en herstelbaar is.

In deze tutorial laat ik je zien hoe je Git instelt, deel ik persoonlijke tips van mijn reis, en help ik je vanaf het begin een robuuste workflow op te zetten.

Wat Is Git Init?

De git init opdracht start je versiebeheertraject. Wanneer je het uitvoert, maakt Git een verborgen .git map aan in je projectdirectory die configuratiegegevens, commitgeschiedenis en alle metadata bevat die nodig is om je wijzigingen bij te houden.

Met elke vastgelegde wijziging kun je zelfverzekerd takken maken, samenvoegen en samenwerken—wetende dat de volledige geschiedenis van je project altijd slechts één opdracht verwijderd is.

Afbeelding door Auteur

Hoe Git Init te Gebruiken

Voordat je je verdiept in geavanceerde onderwerpen, is het essentieel om te begrijpen hoe je git init in de praktijk gebruikt.

Basisgebruik van git init

Volg deze stappen om een nieuw Git-repository vanaf nul te maken:  

  • Open je terminal: Start je voorkeurscommand-line interface.
  • Navigeer naar je projectdirectory:
cd /path/to/your/project

Dit verandert je huidige map naar degene die je wilt volgen.

  • Initialiseer het repository:
git init

Na het uitvoeren van deze opdracht wordt er een verborgen .git-map aangemaakt. Die map slaat alle trackinginformatie van Git op.

  • Controleer de status van het repository:
git status

Op dit moment is Git ingesteld maar volgt het geen bestanden.

Initialiseren van een repository met een bestaand project

Voor projecten die nog niet onder versiebeheer vallen, kun je Git initialiseren en wijzigingen gaan bijhouden als volgt:

  • Navigeer naar je projectdirectory:
cd /path/to/your/project
  • Zet het project om naar een Git-opslagplaats:
git init

Zoals eerder vermeld, maakt het bovenstaande commando de verborgen .git-map aan die Git-tracking mogelijk maakt.

  • Stel je bestanden in fasen op: Aangezien git init niet automatisch bestanden bijhoudt, voeg ze toe met:
git add .
  • Commit je bestanden:Sla de initiële snapshot op door te draaien:  
git commit -m "Initial commit"

Dit proces converteert een onbeheerd project naar een project met een volledige versiegeschiedenis—klaar voor nieuwe ontwikkeling en samenwerking.

Git configureren (indien nodig)

Als je de foutmelding “Auteur identiteit onbekend” tegenkomt, betekent dit dat Git niet weet wie je bent. Om dit op te lossen, configureer je je gebruikersidentiteit:

  • Stel Git gebruikersinformatie in: 
git config --global user.email "[email protected]" git config --global user.name "Your Name"

Met --global worden deze instellingen toegepast op alle repositories op je machine. Het weglaten ervan stelt de identiteit alleen in voor de huidige repository.

  • Controleer uw configuratie:  
git config --global user.email git config --global user.name
  • Probeer de commit opnieuw:  
git commit -m "First Commit"

Ik kreeg deze foutmelding toen ik voor het eerst Git begon te gebruiken—het instellen van mijn identiteit loste het op.

De initiële Git commit is met succes uitgevoerd in PowerShell.

Verbinding maken met een externe repository

Zodra u lokaal een Git-repository hebt geïnitialiseerd, wilt u het waarschijnlijk back-uppen of samenwerken met anderen door het te verbinden met een externe repository (bijv. GitHub, GitLab, Bitbucket).

  • Voeg een externe repository toe: Om je lokale repository te koppelen aan een externe, gebruik:
git remote add origin <repository-url>

Vervang <repository-url> door de URL van je externe repository. origin is de standaard alias voor de externe repository, maar je kunt elke naam gebruiken.

  • Je kunt de verbinding controleren met:
git remote -v
  • Push je wijzigingen naar de externe repository:
# Push de eerste commit en volg de externe branch git push -u origin $(git branch --show-current) # Werkt voor 'main' of 'master'

De bovenstaande opdracht duwt de huidige tak en stelt deze in om de externe tak te volgen.

Als je een oudere versie van Git gebruikt die $(git branch --show-current) niet ondersteunt, gebruik dan:

git push -u origin main # Of 'master' afhankelijk van je standaardtak

Terwijl je blijft werken aan je project, zul je wijzigingen van verschillende takken moeten samenvoegen bij het samenwerken met een team. Leer hoe je merges effectief kunt beheren met deze Git merge tutorial.

Authenticatie en toegang

Als je naar GitHub, GitLab of Bitbucket pusht, moet je je mogelijk authenticeren. Afhankelijk van je setup kun je:

  • Gebruik SSH-sleutels in plaats van HTTPS-authenticatie (aanbevolen voor beveiliging):
git remote set-url origin [email protected]:your-username/your-repo.git
  • Gebruik een Persoonlijke toegangstoken (PAT) in plaats van een wachtwoord bij het gebruik van HTTPS. Voor GitHub, vervang het wachtwoord door een token:
git push https://[email protected]/your-repo.git

Verbinding maken met een externe repository was een keerpunt voor mij – het bevestigde dat mijn lokale werk veilig was opgeslagen en klaar was voor samenwerking. Bovendien gaf het me vertrouwen in versiebeheer, wetende dat mijn geschiedenis bewaard bleef, zelfs als mijn lokale machine zou falen.

Geavanceerde opties met Git Init

Voor degenen die hun Git-configuraties willen aanpassen, bieden geavanceerde opties extra flexibiliteit.

Een bare repository initialiseren

Als je een Git-server opzet waar ontwikkelaars hun wijzigingen kunnen pushen maar geen bestanden direct kunnen bewerken, heb je een bare repository nodig. Een bare repository mist een werkdirectory en bevat alleen versiebeheergegevens. Het wordt meestal gebruikt voor externe repositories:

git init --bare <repository-name>

Bare repositories worden vaak gebruikt in GitOps-workflows, waarbij infrastructuur en applicatie-implementatie via Git worden beheerd. Als je geïnteresseerd bent in het leren hoe GitOps softwarelevering automatiseert en stroomlijnt, bekijk dan deze gids over GitOps.

Initialiseren met specifieke configuratie

Als u aangepaste Git-hooks of configuratiebestanden vanaf het begin nodig heeft, initialiseer dan met een aangepast sjabloon:

git init --template=<template-directory>

Ik heb ooit een aangepast sjabloon gebruikt om essentiële hooks automatisch te laden, wat ons team het implementatieproces stroomlijnde.

Beste praktijken voor het gebruik van Git Init

Met Git op de juiste manier beginnen kan u tijd en problemen besparen in de toekomst.

Uw projectstructuur organiseren

Voordat u git init uitvoert, organiseer uw bestanden in een logische mappenstructuur—scheid code, documentatie en assets.

In één project dat ik overnam, waren bestanden van meerdere deelprojecten door elkaar gehaald, wat leidde tot samenvoegingsconflicten en verwarring. Door alles te herorganiseren in duidelijk gedefinieerde mappen, het repository opnieuw te initialiseren en een juiste .gitignore in te stellen, verbeterde de workflow aanzienlijk.

Het vroeg toevoegen van een .gitignore bestand

Direct na het initialiseren van je repository, maak een .gitignore bestand aan om te voorkomen dat onnodige bestanden worden bijgehouden:

touch .gitignore

Vervolgens bewerk je het om regels toe te voegen zoals:

# Negeer afhankelijkheidsmappen en logbestanden node_modules/ *.log .DS_Store # macOS systeembestand Thumbs.db # Windows systeembestand

Deze stap heeft me behoed voor omvangrijke commitgeschiedenissen en mogelijke toekomstige conflicten.

Voor een gedetailleerde handleiding over het configureren van een .gitignore bestand, bekijk deze gitignore tutorial.

Vaak committen

Door regelmatig kleine commits te maken met duidelijke berichten, bouw je een gedetailleerde projectgeschiedenis op en vereenvoudig je het debuggen en de samenwerking.

Problemen oplossen met het initialiseren van Git

Zelfs met een goede planning kunnen er problemen ontstaan. Hier zijn enkele veelvoorkomende problemen en oplossingen.

Per abuis initialiseren in de verkeerde map

Probleem: Je hebt git init per ongeluk uitgevoerd in de verkeerde map en hebt nu een ongewenst Git repository.

Oplossing:  

  • Verwijder het Git-repository:
rm -rf .git

> Waarschuwing: Hiermee worden alle versiegeschiedenis voor dat repository verwijderd. Zorg ervoor dat je in de juiste map staat voordat je dit commando uitvoert!

Navigeer vervolgens naar de juiste map en voer opnieuw git init uit. 

Ik heb deze fout al een paar keer gemaakt, dus controleer dubbel uw werkmap om dit te voorkomen.

Omgaan met onbewaakte bestanden

Probleem: Na het uitvoeren van git init, houdt Git je bestanden niet bij. Het uitvoeren van git status laat zien:

No commits yet Untracked files: (use "git add <file>..." to include in what will be committed)

Oplossing: 

  • Controleer of de bestanden echt niet worden bijgehouden:
git status

Als je bestanden worden weergegeven onder Niet-bijgehouden bestanden, ziet Git ze wel maar houdt ze nog niet bij.

  • Stel vervolgens de nodige bestanden in voor tracking met:
git add <file-name>
  • Commiteer de bestanden:
git commit -m "Initial commit"

Regelmatige statuscontroles zorgen ervoor dat er niets belangrijks over het hoofd wordt gezien.

Als git status geen bestanden laat zien, controleer dan of je project een .gitignore bestand bevat dat mogelijk belangrijke bestanden uitsluit.

Conclusie

Het beheersen van git init is de cruciale eerste stap naar het opzetten van een betrouwbaar versiebeheersysteem dat samenwerking en efficiënt projectbeheer mogelijk maakt. Volg deze handleiding—van het initialiseren en organiseren van je repository tot het oplossen van veelvoorkomende problemen—om een soepele en efficiënte workflow op te zetten.

Begin klein—initialiseer een testproject met behulp van git init en experimenteer met staging, committen en wijzigingen pushen. Hoe eerder je de basisprincipes van Git onder de knie krijgt, hoe efficiënter je workflow zal zijn! En als je enthousiast bent om je Git-vaardigheden nog verder te verdiepen, bekijk dan deze DataCamp-cursussen:

  • Geavanceerde Git – Verbeter je vaardigheden met geavanceerde branching, merging en conflictresolutietechnieken.
  • GitHub Fundamenten – Leer hoe je Git naadloos integreert met GitHub voor samenwerkingsprojecten.

Veel programmeerplezier—en laten we betrouwbare, innovatieve projecten bouwen met Git!

Source:
https://www.datacamp.com/tutorial/git-init