Phenquestions
Softwareontwikkeling is een samenwerkingstaak. Als software-engineer moet u uw werk met anderen delen. Maar code delen en samenwerken kan ingewikkeld worden. Het is moeilijk om verschillende veranderingen bij te houden die tijdens de levenscyclus van software plaatsvinden. Dus ontwikkelingsteams vertrouwen op versiebeheertools om te helpen bij het softwaresamenwerkingsproces. Git is een van de meest prominente versiebeheertools in de software-industrie.
Tip: In deze tutorial leer je hoe je de basisprincipes van Git . gebruikt. Elke sectie eindigt met een paar vragen. U kunt de vragen lezen voordat u begint met het lezen van de sectie. Dit zal u helpen de belangrijke punten te begrijpen en erop te letten.
Veel plezier met het leren van Git!
Git: een kort overzicht
Git is een gedistribueerd versiebeheersysteem. Het houdt alle wijzigingen bij die u aanbrengt in uw bestanden en mappen. Het maakt het gemakkelijker om uw onderhanden werk op te slaan. Als er een probleem is, kunt u eenvoudig een eerdere versie van het bestand of de map controleren. Indien nodig kun je zelfs je hele codebase terugzetten naar een oudere versie.
De ontwikkeling van Git begon in 2005. De Linux-kernelgroep bewaarde hun code in BitKeeper, een eigen gedistribueerd versiebeheersysteem. BitKeeper heeft het gratis gebruik van het product echter ingetrokken. Dus ontwierp Linus Torvalds, de maker en belangrijkste ontwikkelaar van Linux, een nieuw open-source gedistribueerd versiebeheersysteem dat zou voldoen aan de vereisten van de Linux-ontwikkelgemeenschap. En Git werd geboren.
Als een gedistribueerd versiebeheersysteem heeft Git geen gecentraliseerde autoriteit nodig om de code bij te houden. Oudere gecentraliseerde versiecontroles zoals CVS, SVN of Perforce vereisen centrale servers om de geschiedenis van wijzigingen bij te houden. Git kan alle wijzigingen lokaal bijhouden en peer-to-peer werken. Het is dus veelzijdiger dan gecentraliseerde systemen.
Vragen:
- Waarom zou je Git . gebruiken?
- Wat is het voordeel van gedistribueerd versiebeheer??
Git . installeren
Voor Linux-systemen is het installeren van Git eenvoudig. Als u een op Debian gebaseerde distributie zoals Ubuntu gebruikt, kunt u apt install gebruiken:
$ sudo apt install git-allVoor Fedora, RHEL of CentOS kun je gebruiken:
$ sudo dnf install git-allJe kunt controleren of Git is geïnstalleerd met het volgende commando:
$ git --versieHet zou je de versie van de Git moeten laten zien die je hebt geïnstalleerd, bijvoorbeeld:
git-versie 2.17.0Nadat je Git hebt geïnstalleerd, is het tijd om je gebruikersnaam en e-mailadres in te stellen:
$ git config --global user.naam "uwgebruikersnaam"$ git config --global user.e-mail "[e-mail beveiligd]"
U kunt controleren of de configuraties correct zijn ingesteld met de volgende opdracht:
$ git config --listgebruiker.naam=uwgebruikersnaam
[email protected]
Tip: Het is belangrijk om de gebruiker in te stellen.naam en gebruiker.e-mail omdat deze configuraties worden gebruikt om uw wijzigingen bij te houden.
Vragen
- Wat is de opdracht voor het installeren van Git op je Linux-systeem??
- Waarom zou u een gebruiker instellen?.naam en gebruiker.e-mailconfiguratie? Hoe stel je ze in?
Git conceptueel begrijpen
Om Git te gebruiken, moet je eerst deze vier concepten begrijpen:
- Werkmap
- Verzamelplaats
- Opslagplaats
- Externe opslagplaats
De werkdirectory, het verzamelgebied en de repository zijn lokaal op uw machine. De externe repository kan elke andere computer of server zijn. Laten we deze concepten zien als vier dozen die standaard A1-papieren kunnen bevatten.
Stel, u schrijft een document met de hand op een A1-papier aan uw bureau. U bewaart dit document in het vak van de werkdirectory. In een bepaalde fase van je werk besluit je dat je klaar bent om een kopie te bewaren van het werk dat je al hebt gedaan. Dus je maakt een fotokopie van je huidige papier en stopt deze in de staging box.
De staging box is een tijdelijke ruimte. Als u besluit de fotokopie in de verzamelbox weg te gooien en deze bij te werken met een nieuwe kopie van het werkmapdocument, zal er geen permanente registratie van dat gefaseerde document zijn.
Stel dat u er vrij zeker van bent dat u het document permanent wilt bewaren in de verzamelbox. Vervolgens maakt u een fotokopie van het verzamelboxdocument en verplaatst u het naar de repositorybox.
Wanneer u het naar de opslagplaats verplaatst, gebeuren er twee dingen:
- Een momentopname van het document wordt permanent opgeslagen.
- Er wordt een invoer in het logbestand gemaakt die bij de momentopname past.
De logboekinvoer helpt u die specifieke momentopname van uw document te vinden als u deze in de toekomst nodig heeft.
Nu, in de lokale repository box, heb je een momentopname van je werk en een logboekvermelding. Maar het is alleen voor jou beschikbaar. U maakt dus een kopie van uw lokale archiefdocument samen met het logbestand en stopt het in een doos in de bedrijfsvoorraadkamer. Nu kan iedereen in uw bedrijf een kopie van uw document komen maken en naar hun bureau brengen. De doos in de voorraadkamer zou de externe opslagplaats zijn.
De externe repository is vergelijkbaar met het delen van uw document met Google Docs of Dropbox.
Vragen:
- Kun je werkdirectory, staging, repository en remote repository definiëren??
- Kun je tekenen hoe documenten van de ene fase naar de andere gaan??
Je eerste Git-repository
Zodra je Git hebt geïnstalleerd, kun je beginnen met het maken van je eigen Git-opslagplaatsen. In deze sectie ga je je Git-repository initialiseren.
Stel dat u werkt aan een webontwikkelingsproject. Laten we een map maken met de naam project_helloworld en naar de map gaan:
$ mkdir project_helloworld$ cd-project_helloworld
Je kunt Git vertellen deze map te monitoren met het volgende commando:
$ git initJe zou een uitvoer als deze moeten zien:
Geïnitialiseerde lege Git-repository in /Users/zakh/_work/LearnGIT/git_tutorial/project_helloworld/.git
Nu worden alle bestanden en mappen in project_helloworld bijgehouden door Git.
Vragen:
- Hoe initialiseer je een map die door Git . moet worden gevolgd?
Basis Git-commando's: status, log, toevoegen en commit
Het statuscommando toont de huidige toestand van uw werkdirectory en het logcommando toont de geschiedenis. Laten we het statuscommando proberen:
$ git-statusOp branch master
Initiële commit
niets om vast te leggen (maak/kopieer bestanden en gebruik "git add" om te volgen)
De uitvoer van het git status commando zegt dat je op de master branch zit. Dit is de standaard branch die Git initialiseert. (U kunt uw eigen takken maken). Later meer over takken). De output zegt ook dat er niets te committen is.
Laten we het log-commando proberen:
$ git logfataal: je huidige branch 'master' heeft nog geen commits
Het is dus tijd om wat code te maken. Laten we een bestand maken met de naam index.html:
Hallo Wereld
U kunt de teksteditor gebruiken om het bestand te maken. Nadat u het bestand hebt opgeslagen, controleert u de status opnieuw:
$ git-statusOp branch master
Initiële commit
Niet-getrackte bestanden:
(gebruik "git add ."
inhoudsopgave.html
niets toegevoegd om vast te leggen maar niet-getrackte bestanden aanwezig (gebruik "git add" om te volgen)
Git vertelt je dat je een bestand hebt met de naam index.html in uw werkmap die niet wordt bijgehouden.
Laten we ervoor zorgen dat index.html wordt bijgehouden. U moet de opdracht toevoegen gebruiken:
$ git add index.htmlAls alternatief kunt u de ".” Optie om alles in de directory toe te voegen:
$ git toevoegen .Laten we nu de status opnieuw controleren:
$ git-statusOp branch master
Initiële commit
Door te voeren wijzigingen:
(gebruik "git rm --cached"
nieuw bestand: index.html
Het groen geeft aan dat de index.html-bestand wordt gevolgd door Git.
Tip: Zoals vermeld in de bovenstaande instructies, als u de opdracht gebruikt:
$ git rm --cached index.htmlUw index.html keert terug naar de niet-bijgehouden status. Je moet het opnieuw toevoegen om het terug te brengen naar staging.]
Laten we het logboek nog eens bekijken:
$ git logfataal: je huidige branch 'master' heeft nog geen commits
Dus ook al volgt Git de index.html, er is nog niets in de Git-repository over het bestand. Laten we onze wijzigingen vastleggen:
$ git commit -m "Committ index.html"De uitvoer zou er ongeveer zo uit moeten zien:
[master (root-commit) f136d22] Committing-index.html
1 bestand gewijzigd, 6 invoegingen (+)
aanmaakmodus 100644 index.html
De tekst tussen de aanhalingstekens na de "-m" is een opmerking die in het logbestand komt. Je kunt git commit gebruiken zonder "-m", maar dan zal Git een teksteditor openen die je vraagt om de opmerkingen te schrijven. Het is gemakkelijker om de opmerkingen gewoon rechtstreeks op de opdrachtregel te plaatsen.
Laten we nu ons logbestand eens bekijken:
$ git logcommit f136d22040ba81686c9522f4ff94961a68751af7
Auteur: Zak H
Datum: ma 4 juni 16:53:42 2018 -0700
Vastleggen index.html
Je kunt zien dat het een commit toont. U heeft uw wijzigingen succesvol doorgevoerd in uw lokale repository. Als u hetzelfde logboek op een beknopte manier wilt zien, kunt u het volgende commando gebruiken:
$ git log --onelinef136d22 Vastleggen index.html
In de toekomst zullen we deze vorm van het log-commando gebruiken omdat dit het gemakkelijker maakt om te begrijpen wat er aan de hand is.
Laten we beginnen met het bewerken van de index.html. Open de index.html-bestand in een editor en verander de regel "Hallo wereld" in "Hallo wereld"! Ik ben het!" en sla het op. Als je de status nogmaals controleert, zul je zien dat Git heeft gemerkt dat je het bestand aan het bewerken bent:
$ git-statusOp branch master
Wijzigingen niet gestaged voor commit:
(gebruik "git add ."
(gebruik "git checkout" --
gewijzigd: index.html
geen wijzigingen toegevoegd aan commit (gebruik "git add" en/of "git commit -a")
De wijziging staat nog steeds in uw werkmap. Je moet het naar het verzamelgebied duwen. Gebruik het add-commando dat je eerder gebruikte:
$ git toevoegen .Controleer nogmaals de status:
$ git-statusOp branch master
Door te voeren wijzigingen:
(gebruik "git reset HEAD"
gewijzigd: index.html
Uw wijzigingen bevinden zich nu in het staging-gebied. U kunt het vastleggen in de repository voor permanente bewaring:
$ git commit -m "Gewijzigde index.html naar een vrolijker bericht"[master 0586662] Gewijzigde index.html naar een vrolijker bericht
1 bestand gewijzigd, 1 toevoeging (+), 1 verwijdering (-)
U kunt het logboek controleren op uw permanente wijzigingen:
$ git log --oneline0586662 Gewijzigde index.html naar een vrolijker bericht
f136d22 Vastleggen index.html
In deze sectie heb je geleerd hoe je de commando's status, log, add en commit kunt gebruiken om je documenten in Git . bij te houden.
Vragen:
- Wat doet git-status??
- Wat doet git log??
- Wat doet git add??
- Wat doet git commit??
Teruggaan naar oudere bestanden met behulp van Checkout
Wanneer je een bestand commit in Git, maakt het een unieke hash voor elke commit. U kunt deze als identificatie gebruiken om terug te keren naar een oudere versie.
Stel dat u terug wilt naar uw eerdere versie van index.html. Laten we eerst eens kijken naar de index.html in de huidige staat:
$ kattenindex.htmlHallo Wereld! Ik ben het!
Je kunt zien dat je de nieuwere versie hebt (“Hallo wereld! Ik ben het!”). Laten we het logboek eens bekijken:
$ git log --oneline0586662 Gewijzigde index.html naar een vrolijker bericht
f136d22 Vastleggen index.html
De hash voor de vorige versie was f136d22 ("Hallo wereld"). U kunt het checkout-commando gebruiken om naar die versie te gaan:
$ git kassa f136d22Let op: check out 'f136d22'.
U bevindt zich in de staat 'vrijstaand HOOFD'. U kunt rondkijken, experimentele wijzigingen aanbrengen
en commit ze, en je kunt alle commits die je in deze staat doet weggooien
zonder filialen te beïnvloeden door nog een checkout uit te voeren.
Als je een nieuwe branch wilt maken om commits die je hebt gemaakt te behouden, kun je:
doe dit (nu of later) door -b opnieuw te gebruiken met het checkout-commando. Voorbeeld:
git checkout -b
HEAD staat nu op f136d22... Committing index.html
Als je kijkt naar de inhoud van index.html, ziet u:
$ kattenindex.htmlHallo Wereld
Het heeft alleen "Hallo wereld". Dus uw index.html is gewijzigd in de oudere versie. Als u de status controleert:
$ git-statusHOOFD losgemaakt op f136d22
niets te committen, werkmap opschonen
Git vertelt je eigenlijk dat de HEAD niet de meest recente commit is. Je kunt teruggaan naar de meest recente commit door de master branch uit te checken met het volgende commando:
$ git checkout masterVorige HEAD-positie was f136d22... Committing index.html
Overgeschakeld naar tak 'master'
Als u nu de status controleert:
$ git-statusOp branch master
niets te committen, werkmap opschonen
De rode waarschuwing is weg. Ook als u uw index controleert.html, zou je terug moeten zijn naar de nieuwste versie:
$ kattenindex.htmlHallo Wereld! Ik ben het!
De checkout-opdracht brengt je naar verschillende staten. We zullen meer leren over afrekenen in de volgende sectie.
Vragen:
- Hoe gebruik je het git checkout-commando om naar een oudere versie van een bestand te gaan??
- Hoe gebruik je git checkout om terug te gaan naar de nieuwste versie van het bestand??
Afrekenen, vertakkingen en samenvoegen
Vertakking is een van de beste eigenschappen van Git. Het helpt je om je werk te scheiden en meer te experimenteren. In andere versiebeheersystemen was vertakking tijdrovend en moeilijk. Git maakte vertakkingen en samenvoegen gemakkelijker.
Zoals je opmerkte in het status commando, wanneer je een nieuwe Git repository aanmaakt, ben je in de master branch.
$ git-statusOp branch master
niets te committen, werkmap opschonen
Stel dat je een website maakt voor je vriend David. U wilt de code van uw eigen website hergebruiken. Vertakking is een geweldige oplossing. Laten we de vestiging david_website noemen.
U kunt de volgende opdracht geven:
$ git branch david_websiteU kunt de volgende opdracht gebruiken om alle takken te zien:
$ git branch --listdavid_website
* meester
De ster(*) naast master betekent dat je nog steeds in de master-branch bent. Je kunt de david_website branch bekijken met het volgende commando:
$ git afrekenen david_websiteOvergeschakeld naar tak 'david_website'
Als u nu de filiaallijst opnieuw controleert, ziet u:
$ git branch --list* david_website
meester
Dus je bent op de david_website branch.
Laten we de index veranderen.html van “Hallo wereld! Ik ben het!” naar “Hallo wereld! Het is David!” en vervolgens stage en commit:
$ git toevoegen .$ git commit -m "Website gewijzigd voor David"
Als je de logboeken bekijkt, zou je het volgende moeten zien:
$ git log --oneline345c0f4 Gewijzigde website voor David
0586662 Gewijzigde index.html naar een vrolijker bericht
f136d22 Vastleggen index.html
En uw indexbestand zou er als volgt uit moeten zien:
$ kattenindex.htmlHallo Wereld! Het is David!
Laten we nu de master branch nog eens bekijken:
$ git checkout masterOvergeschakeld naar tak 'master'
Als u de status controleert en logt:
$ git-statusOp branch master
niets te committen, werkmap opschonen
$ git log --oneline
0586662 Gewijzigde index.html naar een vrolijker bericht
f136d22 Vastleggen index.html
Merk op dat je je derde commit niet in de master hebt. Omdat die commit alleen wordt onderhouden in de david_website branch.
Dit is wat er gebeurde
Stel dat u in dit stadium besluit dat u niet verder wilt met uw website. Jij bent gewoon de ontwikkelaar voor David. Dus je wilt de wijzigingen in de david_website branch samenvoegen met de master. Vanuit de master branch hoef je alleen maar de volgende commando's te geven (het status commando wordt gebruikt om te controleren of je op de juiste plek bent):
$ git-statusOp branch master
niets te committen, werkmap opschonen
$ git merge david_website
0586662 bijwerken... 345c0f4
Vooruitspoelen
inhoudsopgave.html | 2 +-
1 bestand gewijzigd, 1 toevoeging (+), 1 verwijdering (-)
Tip: Je trekt wijzigingen van david_website naar master. Je moet op de meester zijn om dit te bereiken.
Als je nu het logboek op de master bekijkt, zie je dat de derde commit er is:
$ git log --oneline345c0f4 Gewijzigde website voor David
0586662 Gewijzigde index.html naar een vrolijker bericht
f136d22 Vastleggen index.html
Je hebt de david_website branch met succes samengevoegd tot master. En je index.html voor master branch ziet er identiek uit als david_website branch:
$ kattenindex.htmlHallo Wereld! Het is David!
U kunt de vertakking david_website behouden:
$ git branch --listdavid_website
* meester
Of je kunt het verwijderen:
$ git branch -d david_websiteBranch david_website verwijderd (was 345c0f4).
Na het verwijderen zou je de david_website branch niet meer moeten zien:
$ git branch --list* meester
Tip: Als Git tijdens een samenvoeging niet automatisch kan samenvoegen, krijg je samenvoegconflictfouten. In dat geval moet u de samenvoegproblemen handmatig oplossen.
Vragen:
- Waarom heb je vertakkingen nodig??
- Hoe vertakt en voegt u bestanden en mappen samen??
Externe opslagplaats
Tot nu toe was al je werk lokaal. Je hebt je wijzigingen doorgevoerd in een lokale repository. Maar het is tijd om je werk met de wereld te delen.
Git remote repository is in feite een andere kopie van je lokale repository die toegankelijk is voor anderen. U kunt een server opzetten en er de externe repository van maken. Maar de meeste mensen gebruiken hiervoor GitHub of Bitbucket. U kunt daar gratis openbare repositories maken die voor iedereen toegankelijk zijn.
Laten we een externe repository maken op GitHub.
Eerst moet je een GitHub-account maken[]. Zodra je het account hebt, maak je een nieuwe repository aan met de knop "Nieuwe repository". Gebruik "project_website" als de naam van de repository (je kunt iets anders kiezen als je wilt).
U zou een Code-tabblad moeten zien met instructies zoals deze:
... of maak een nieuwe repository op de opdrachtregel
echo "# project_website" >> README.mdgit init
git add README.md
git commit -m "eerste commit"
git remote oorsprong toevoegen [email protected]:uwgebruikersnaam/project_website.git
git push -u origin master
Kopieer het volgende “git remote add origin” commando en voer het uit in je werkmap:
$ git remote oorsprong toevoegen [email protected]:uwgebruikersnaam/project_website.gitOpmerking: in jouw geval zou je gebruikersnaam moeten zijn wat je hebt gebruikt om je GitHub-account aan te maken.
In de bovenstaande opdracht heb je Git de locatie van de externe repository geïnstrueerd:. De opdracht vertelt Git dat de "oorsprong" voor uw project_helloworld-werkmap "[email protected]:uwgebruikersnaam/project_website zal zijn.git”.
Push nu je code van je master branch naar origin (remote repository):
$ git push origin masterObjecten tellen: 9, klaar.
Delta-compressie met maximaal 4 threads.
Objecten comprimeren: 100% (6/6), klaar.
Objecten schrijven: 100% (9/9), 803 bytes | 0 bytes/s, klaar.
Totaal 9 (delta 2), hergebruikt 0 (delta 0)
afstandsbediening: Delta's oplossen: 100% (2/2), klaar.
Naar [email protected]:uwgebruikersnaam/project_website.git
* [nieuwe branch] master -> master
Als je je browser vernieuwt in GitHub, zou je moeten zien dat de index.html-bestand staat daarboven. Uw code is dus openbaar en andere ontwikkelaars kunnen de code in de externe repository uitchecken en wijzigen.
Als ontwikkelaar werk je met de code van anderen. Het is dus de moeite waard om de code van GitHub te proberen.
Laten we naar een nieuwe map gaan waar je niets hebt. Aan de rechterkant van de GitHub-repository zie je de knop "Klonen of downloaden". Als je erop klikt, zou het je een SSH-adres moeten geven. Voer de volgende opdracht uit met het SSH-adres:
$ git kloon [email protected]:uwgebruikersnaam/project_website.gitDe uitvoer zou er als volgt uit moeten zien:
$ git kloon [email protected]:uwgebruikersnaam/project_website.gitKlonen naar 'project_website'…
afstandsbediening: Objecten tellen: 9, klaar.
afstandsbediening: Objecten comprimeren: 100% (4/4), klaar.
afstandsbediening: Totaal 9 (delta 2), hergebruikt 9 (delta 2), hergebruikt 0
Objecten ontvangen: 100% (9/9), klaar.
Delta's oplossen: 100% (2/2), klaar.
Verbinding controleren... klaar.
Het zal een project_website maken in je schone map. Als je naar binnen gaat, zou je de index moeten zien.html van je project_helloworld.
Je hebt dus het volgende bereikt:
- Gemaakt en wijzigingen aangebracht in project_helloworld
- De code geüpload naar GitHub in project_website
- De code gedownload van GitHub
Laten we nog een bestand uit de nieuwe werkmap project_website:
$ raak LeesMij aan.md$ git toevoegen .
$ git commit -m "Leesmij toegevoegd.md"
$ git push origin master
Als je de GitHub project_website pagina vernieuwt, zou je de ReadMe . moeten zien.md-bestand daar.
Opmerking: wanneer u code downloadt van GitHub, kent de werkdirectory automatisch de oorsprong. Je hoeft het niet te definiëren met het "git remote add origin" commando.
Vragen:
- Waarom moet u externe opslagplaatsen gebruiken??
- Hoe stel je je huidige lokale repository in om verbinding te maken met de remote repository??
- Hoe kloon je externe opslagplaatsen naar je lokale computer??
Conclusie
Meer informatie over alle commando's vind je in de Git docs[]. Hoewel er Git UI-tools beschikbaar zijn, is de opdrachtregel de beste manier om Git . onder de knie te krijgen. Het geeft je een sterkere basis voor je ontwikkelingswerk.
Verdere studie:
- https://git-scm.com/docs
- https://git-scm.com/boek/nl/v2
- https://git-scm.com/video's
