Geavanceerde Git-zelfstudie

Door uw project via een externe repository te implementeren, kunt u elk onderdeel flexibel beheren. Bugfixes, functie-updates, bestandsverwijdering, teamwerk, open-source bijdragen, code-implementatie en meer zijn nu binnen handbereik met een sterke kennis van Git.

Dus je hebt Git gebruikt, maar wil je meer weten? Hier zijn enkele meer geavanceerde Git-tips die uw projectversiebeheer een fluitje van een cent maken.

Git Branch

Een Git branch voorkomt dat je direct naar de master branch pusht. Het is handig als je een project beheert met een team van ontwikkelaars. Je kunt zoveel Git-takken maken als je wilt en ze later samenvoegen met de master-branch.

Een Git-vertakking maken

Gebruik om een Git branch te maken:

git branch branch_name

Overschakelen naar een Git Branch

Gebruik maken van uitchecken om over te schakelen naar een Git branch:

git checkout branch_name

Nadat u naar een branch bent overgeschakeld, kunt u uw wijzigingen faseren met git add --all . Leg ze dan vast met de git commit -m 'commit naam' opdracht.

Vergelijk een filiaal met Master

Gebruik de git verschil opdracht:

git diff master..branch_name

Om specifieke bestanden te vergelijken:

git diff master..testb -- main.html

Het vergelijken van twee branches is vergelijkbaar met hoe je een branch vergelijkt met de master:

git diff branch1..branch2

Om de verschillen in een specifiek bestand tussen twee takken te zien:

git diff branch1..branch2 -- main.html

Wijzigingen naar een externe vestiging pushen

Misschien wil je dat een andere ontwikkelaar naar de wijzigingen kijkt die je hebt gemaakt in een bestand in je lokale branch voordat ze live worden gepusht. Een goede gewoonte is om je lokale Git-branch naar een externe replica te schuiven, zodat ze een kijkje kunnen nemen.

Laten we aannemen dat je eerder een lokale branch hebt aangemaakt met de naam veranderingen . Je kunt naar die lokale branch overschakelen, alle bestanden aanpassen die je wilt, ze vervolgens stagen en committen aan die branch.

U kunt die wijzigingen vervolgens naar de externe versie van de vertakking pushen:

git push origin changes

Voeg externe vertakking samen met master met behulp van pull-verzoek

Dus een andere programmeur heeft de wijzigingen in de remote branch gecontroleerd ( veranderingen ). Maar je wilt het mergen met de master branch en het live pushen.

Onthoud dat je remote branch de naam erft van je lokale Git branch ( veranderingen ). Ga als volgt te werk om de wijzigingen samen te voegen:

Schakel over naar de master-branch:

git checkout master

Trek aan de oorsprong of HEAD van de tak ( veranderingen ) om het samen te voegen met de master -branch:

git pull origin changes

Push deze merge live naar de master branch:

git push origin master

Gebruik in plaats daarvan Git Merge

Om een vertakking met de master samen te voegen met de Gaan opdracht:

Migreren naar de master branch:

git checkout master

Voeg het samen met de branch ( veranderingen ):

git merge changes

Duw dan de merge live naar de master -branch:

een of meer video's zijn uit de afspeellijst verwijderd omdat ze van YouTube zijn verwijderd.

git push origin master

Zorg ervoor dat u vervangt veranderingen met de naam van uw filiaal.

Zodra een samenvoeging is gelukt, kunt u vervolgens verwijder de branch lokaal en op afstand als je het niet meer nodig hebt:

Verwant: Een filiaal hernoemen in Git

Git-rebase

Als je meerdere branches hebt met verouderde commits, kun je de . opnieuw baseren of herfocussen hoofd/refs van die takken om de . te erven hoofd/refs van een bijgewerkte.

Rebasen is daarom handig wanneer u sommige takken moet bijwerken met de basis van een huidige.

Rebasen zou echter geen frequente actie moeten zijn, vooral als u met een team werkt, omdat dit de hele workflow kan verstoren. Maar als je alleen werkt en bekend bent met je workflow en branches, zou rebasen geen schade moeten aanrichten als je weet waar en hoe je het moet gebruiken.

Stel bijvoorbeeld dat je twee takken hebt; tak1 en tak2. Nu heb je al een tijdje geen wijzigingen meer aangebracht in branch1. Maar je voert consequent wijzigingen door in branch2, ook recentelijk.

Dus je hebt besloten om branch1 mee te nemen met de stroom. Het rebasen van branch1 naar branch2 betekent daarom dat je branch1 vertelt om zijn eerdere commits te negeren en de recente commit gemaakt naar branch2 te erven.

Hier leest u hoe u dat kunt doen:

Schakel over naar de verlaten tak (tak1):

git checkout branch1

Rebase vervolgens branch1 naar de bijgewerkte branch2:

git rebase branch2

Git Squash

Met Git squash kun je meerdere commits samenvoegen tot één. Het helpt als je rent git commit vaak op een enkele update. Een praktisch voorbeeld is wanneer elke bugfix of coderefactor voor een enkele functie een afzonderlijke commit heeft.

Maar misschien wil je de HEAD-commit niet pushen met de bijbehorende, omdat ze allemaal hetzelfde doel hebben. Een aanbevolen benadering is om ze in één te pletten om verwarring te voorkomen bij het volgen van commits.

De beste manier om commits te squashen is via de interactieve rebase-modus. Bekijk het onderstaande voorbeeld om dit beter te begrijpen.

Ga er in dit voorbeeld vanuit dat je vijf bugfixes hebt. En er is een verplichting voor elk van hen. Hier is hoe je deze vijf commits in één kunt pletten:

Loop git reflog om de hashcode van je commits te bekijken:

git reflog

Dit is het resultaat in dit geval:

Nu is je doel om de laatste vijf commits te pletten, te beginnen met eerste oplossing tot vijfde oplossing .

Om dat te doen, kopieer je de hash-code van de commit net eronder eerste oplossing ( 0a83962 ). Druk vervolgens op Q stoppen met opnieuw loggen .

Nu rennen git rebase --interactive op die hasj.

git rebase --interactive 0a83962

Git opent dan een interactief rebase-bestand dat er als volgt uitziet:

Om de commits te pletten, met uitzondering van de eerste oplossing , vervangen kiezen met s voor elk van de andere commits:

Bewaar en sluit dit bestand.

Er wordt dan een ander bestand geopend waarin je de gecomprimeerde commit kunt hernoemen:

hoe alle gebruikers in linux weer te geven

Maak die schoon en typ een voorkeursnaam voor de gepletste commit:

Sla dat bestand op. Sluit het vervolgens en u zou een succesbericht in uw terminal moeten ontvangen.

Opmerking: Het interactieve bestand kan in de terminal worden geopend. Maar als je Windows gebruikt, wil je misschien je terminal dwingen om bestanden wereldwijd te openen naar je favoriete teksteditor om het pletten gemakkelijk te maken.

Open hiervoor uw opdrachtregel en voer het volgende uit:

git config --global core.editor ''path to choice text editor' -n -w'

Git Fork versus Git Clone

Forken en klonen zijn twee verschillende termen in Git. Je kunt je repository niet forken omdat het er al bij je is. U kunt echter de repository van andere mensen forken en deze daarna klonen.

Forking van een repository betekent dat je een kopie van iemands repository pakt en het van jou maakt. Zodra je een kopie van die repository hebt gekregen, kun je deze klonen zoals je zou doen met een van je git-repository's voor lokale wijzigingen.

Zo doe je dat een externe repository klonen op GitHub en start een download naar uw lokale map:

git clone https://github.com/username/repository_name.git/

Een bestand terugzetten naar de standaardstatus

Als je de wijzigingen in een bestand wilt wissen na de laatste vastlegging, kun je de gebruiken git restore opdracht:

git restore filename

Een verbintenis wijzigen

Je kunt terugvallen op een eerdere commit als je vergeet om wijzigingen aan te brengen in sommige bestanden terwijl je ze stagneert.

Breng wijzigingen aan in het bestand dat u bent vergeten. Gebruik dan git wijzigen om een commit te beoordelen:

git add file_forgotten  
git commit --amend

Unstage-bestanden

Je kunt specifieke bestanden die je hebt voorbereid voor een commit verwijderen met ga rm opdracht:

git rm --cached filename

U kunt ook meerdere bestanden tegelijk verwijderen:

git rm --cached file1 file2 file3 file4

Vergeet niet om de relevante bestandsextensie toe te voegen aan elk bestand dat u vrijstelt. Een tekstbestand zonder opmaak zou bijvoorbeeld moeten zijn: bestandsnaam.txt .

Verwant: Git opschonen en niet-bijgehouden bestanden verwijderen

Git resetten

Gebruik makend van git reset is handig als je alle bestanden die je hebt gestaged voor een commit in één keer wilt laten vallen:

git reset

Git reset HEAD wijst echter de HEAD van een branch naar een specifieke commit in je werkboom. Als je bijvoorbeeld je huidige commit nog niet hebt gepusht, kun je terugvallen op de recent gepushte commit:

git reset --soft HEAD~1

Vervangen --zacht met --moeilijk als je de huidige commit al hebt gepusht:

git reset --hard HEAD~1

Ga terug

In tegenstelling tot de resetten opdracht, ga terug handhaaft de integriteit van uw commit-geschiedenis. Het is handig als je een commit wilt wijzigen vanwege fouten of bugs.

Het verlaat de doel-commit niet en maakt geen nieuwe. In plaats daarvan keert het terug naar de recente wijzigingen die je aanbrengt zonder een dergelijke commit te verwijderen of te hernoemen. Het is een geweldige manier om je commits schoner te houden, en het is ook veiliger dan steeds opnieuw in te stellen.

Om terug te keren naar een commit:

git revert HEAD~1

Waar HOOFD~1 wijst naar een specifieke commit in je werkboom.

Een bijgehouden bestand of een map verwijderen

Je kunt gebruiken git rm -f om alle bijgehouden bestanden in uw werkboom te verwijderen. Merk echter op dat Git niet-getrackte bestanden niet kan verwijderen, omdat het ze niet in de cache plaatst.

Een gefaseerd bestand verwijderen:

git rm -f filename

Een gefaseerde map verwijderen:

git rm -r -f foldername

Git-logboekregistratie

Om je commit logs en geschiedenis in Git te bekijken:

git log

Om de activiteiten in een specifieke tak te loggen:

git log branch_name

Verwant: Hoe de geschiedenis van een project te inspecteren met git log

Soms wil je misschien teruggaan naar een verlaten commit. Dus om verlaten commits te bekijken, inclusief de relevante:

git reflog

Om ref logs voor een bepaalde tak te bekijken:

git reflog branch_name

Beheer uw projectversies als een professional met Git

Omdat Git veel voordelen biedt, kunt u uw projectreleases op afstand beheren zonder bestanden en mappen op locatie in uw hoofdfiliaal in te breken. Bovendien kunt u projecten eenvoudig met een team uitvoeren.

Zoals je hebt gezien, heeft Git veel functies die je kunt verkennen. Maar wees voorzichtig om deze functies doelbewust te gebruiken. Anders zou je dingen kunnen breken. Dat gezegd hebbende, je kunt nog steeds een demo-repository op afstand starten en met deze functies spelen.

Deel Deel Tweeten E-mail Beheer uw bestandsversies als een programmeur met Git

Programmeurs hebben versiebeheersystemen (VCS) gemaakt om problemen met bestandsversiebeheer op te lossen. Laten we eens kijken naar de basisprincipes van versiebeheer met behulp van het topsysteem van vandaag, Git.

Lees volgende Gerelateerde onderwerpen

Programmeren
Webontwikkeling
GitHub
Codeerhandleidingen

Over de auteur Idisou Omisola(94 artikelen gepubliceerd)

Idowu is gepassioneerd door alles wat slimme technologie en productiviteit betreft. In zijn vrije tijd speelt hij met coderen en schakelt hij over naar het schaakbord als hij zich verveelt, maar hij vindt het ook heerlijk om af en toe uit de routine te stappen. Zijn passie om mensen de weg te wijzen in moderne technologie motiveert hem om meer te schrijven.

Meer van Idowu Omisola

Abonneer op onze nieuwsbrief

Word lid van onze nieuwsbrief voor technische tips, recensies, gratis e-boeken en exclusieve deals!

Klik hier om je te abonneren