Avancerad Git -handledning

Genom att distribuera ditt projekt via ett fjärrförråd kan du flexibelt hantera varje del av det. Felkorrigeringar, funktionsuppdateringar, radering, lagarbete, öppen källkod, koddistribution och mer finns nu till hands med stark kunskap om Git.

Så du har använt Git men vill veta mer? Här är några mer avancerade Git -tips som gör din projektversionskontroll till en vind.

Git gren

En Git -gren hindrar dig från att skjuta direkt till huvudgrenen. Det är bra om du hanterar ett projekt med ett team av utvecklare. Du kan skapa så många Git -grenar du vill och sedan slå ihop dem till huvudgrenen senare.

Skapa en Git -gren

För att skapa en Git -gren, använd:

git branch branch_name

Byt till en Git -gren

Använda sig av kolla upp för att byta till en Git -gren:

git checkout branch_name

När du har bytt till en filial kan du göra dina ändringar med git add -allt . Begå dem sedan med git commit -m 'commit name' kommando.

Jämför en gren med Master

Använd git diff kommando:

git diff master..branch_name

Så här jämför du specifika filer:

git diff master..testb -- main.html

Att jämföra två grenar liknar hur du jämför en gren med befälhavaren:

git diff branch1..branch2

För att se skillnaderna i en specifik fil mellan två grenar:

git diff branch1..branch2 -- main.html

Skjut ändringar till en fjärrenhet

Du kanske vill att en annan utvecklare ska titta på de ändringar du har gjort i en fil i din lokala filial innan du skickar dem live. En bra metod är att skjuta din lokala Git -filial till en fjärrreplika så att de kan titta.

Låt oss anta att du tidigare har skapat en lokal filial med namnet ändringar . Du kan byta till den lokala grenen, justera alla filer du vill ha, sedan iscensätta och överlåta dem till den grenen.

Du kan sedan flytta ändringarna till fjärranslutningen av grenen:

git push origin changes

Slå ihop fjärrenhet med master med Pull Request

Så en annan programmerare har granskat ändringarna i den avlägsna grenen ( ändringar ). Men du vill slå ihop den med huvudgrenen och driva den live.

Kom ihåg att din avlägsna filial ärver namnet på din lokala Git -filial ( ändringar ). Så här slår du ihop ändringarna:

Byt till huvudgrenen:

git checkout master

Dra i grenens eller huvudets huvud ( ändringar ) för att slå ihop det med huvudgrenen:

git pull origin changes

Skjut denna sammanfogning live till huvudgrenen:

git push origin master

Använd Git Merge istället

Att slå samman en gren med befälhavaren med hjälp av gå kommando:

Migrera till huvudgrenen:

git checkout master

Slå ihop det med grenen ( ändringar ):

git merge changes

Skjut sedan sammanfogningen live till huvudgrenen:

hur mycket data använder youtube tv

git push origin master

Se till att du byter ut ändringar med namnet på din gren.

När en sammanslagning har lyckats kan du sedan ta bort filialen lokalt och på distans om du inte behöver det längre:

Relaterad: Hur man byter namn på en filial i Git

Git Rebase

Om du har flera grenar med föråldrade åtaganden kan du ombasera eller omfokusera huvud/refs av dessa grenar för att ärva huvud/refs av en uppdaterad.

Rebasing är därför praktiskt när du behöver uppdatera några grenar med basen av en nuvarande.

Rebasing bör dock inte vara en frekvent åtgärd, särskilt om du arbetar med ett team eftersom det kan störa hela arbetsflödet. Men om du arbetar ensam och är bekant med ditt arbetsflöde och grenar, bör rebasing inte orsaka kaos om du vet var och hur du använder det.

Anta till exempel att du har två grenar; gren1 och gren2. Nu har du inte gjort några ändringar i branch1 på ett tag. Men du gör konsekvent ändringar i branch2, inklusive nyligen.

Så du bestämde dig för att bära gren1 tillsammans med flödet. Att omgränsa gren1 till gren2 betyder därför att du säger till gren1 att ignorera dess tidigare åtaganden och ärva den senaste åtagandet som gjordes till gren2.

Så här kan du göra det:

Byt till den övergivna grenen (gren1):

git checkout branch1

Starta sedan om gren1 till den uppdaterade grenen2:

git rebase branch2

Git Squash

Med Git -squash kan du slå ihop flera åtaganden till en. Det hjälper när du springer git begå många gånger på en enda uppdatering. Ett praktiskt exempel är när varje buggfix eller kodrefaktor för en enda funktion har en separat åtagande.

Men du kanske inte vill driva HEAD -åtagandet med de medföljande eftersom de alla har samma syfte. Ett rekommenderat tillvägagångssätt är att klämma in dem i ett för att undvika förvirring när spårning begår.

Det bästa sättet att squasha åtaganden är via det interaktiva rebase -läget. Ta en titt på exemplet nedan för att förstå detta bättre.

Anta i det här exemplet att du har fem buggfixar. Och det finns ett åtagande för var och en av dem. Så här kan du krossa dessa fem åtaganden till en:

Springa git reflog för att visa hashkoden för dina åtaganden:

git reflog

Här är resultatet i det här fallet:

Nu är ditt mål att krossa de fem sista åtagandena, från och med första fix upp till femte fixen .

För att göra det, kopiera hashkoden för åtagandet precis nedan första fix ( 0a83962 ). Tryck sedan på F att sluta reflog .

Kör nu git rebase -interaktiv på den hashen.

git rebase --interactive 0a83962

Git öppnar sedan en interaktiv rebase -fil som ser ut så här:

För att klämma åtagandena, exklusive första fix , byta ut plocka med s för var och en av de andra förbinder sig:

Spara och stäng den här filen.

En annan fil öppnas sedan för dig att byta namn på den klämda åtagandet:

fel när mappinnehållet inte laddades upp

Rengör dem och skriv in ett föredraget namn för den klämda åtagandet:

Spara den filen. Stäng sedan den och du bör få ett framgångsmeddelande i din terminal.

Notera: Den interaktiva filen kan öppnas i terminalen. Men om du använder Windows kanske du vill tvinga din terminal att globalt öppna filer till din favorittextredigerare för att göra squashingen enkel.

För att göra det, öppna din kommandorad och kör:

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

Git Fork vs Git Clone

Gaffel och kloning är två olika termer i Git. Du kan inte gaffla ditt förråd eftersom det redan finns där. Du kan dock gaffla andras förvar och klona det efteråt.

Gaffla ett förvar betyder att du tar en kopia av någons förvar och gör den till din. När du väl har fått en kopia av det förvaret kan du sedan klona det som om du gör någon av dina git -arkiv för lokala ändringar.

Så här gör du klona ett fjärrförråd på GitHub och starta en nedladdning till din lokala katalog:

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

Återställ en fil till dess standardläge

Om du vill rensa ändringarna i en fil efter det senaste åtagandet kan du använda git -återställning kommando:

git restore filename

Ändra ett åtagande

Du kan falla tillbaka till ett tidigare åtagande om du glömmer att göra ändringar i vissa filer medan du lagrar dem.

Gör ändringar i filen du glömde. Använd sedan git ändra att granska ett åtagande:

git add file_forgotten  
git commit --amend

Unstage -filer

Du kan ta bort specifika filer som du har iscensatt för ett åtagande med gå rm kommando:

git rm --cached filename

Du kan också ta bort flera filer samtidigt:

git rm --cached file1 file2 file3 file4

Kom ihåg att bifoga det relevanta filtillägget till alla filer du undantar. Till exempel bör en vanlig textfil vara filnamn.txt .

Relaterad: Hur man rengör Git och tar bort ospårade filer

Git Återställ

Använder sig av git reset är till hjälp om du vill släppa alla filer som du har iscensatt för ett åtagande på en gång:

git reset

Git reset HEAD pekar dock HEAD på en gren till en specifik åtagande i ditt arbetsträd. Till exempel, om du ännu inte har drivit ditt nuvarande engagemang kan du falla tillbaka till det nyligen tryckta engagemanget:

git reset --soft HEAD~1

Byta ut --mjuk med --hård om du redan har drivit det nuvarande åtagandet:

git reset --hard HEAD~1

Gå tillbaka

till skillnad från återställa kommando, gå tillbaka bibehåller integriteten i din engagemangshistorik. Det är praktiskt om du vill ändra ett åtagande på grund av fel eller buggar.

Det överger inte målet eller gör ett nytt. Istället återgår det till de senaste ändringarna du gör utan att radera eller byta namn på ett sådant åtagande. Det är ett bra sätt att hålla dina åtaganden renare, plus att det är säkrare än att återställa hela tiden.

För att återgå till ett åtagande:

git revert HEAD~1

Var HEAD ~ 1 pekar på ett specifikt åtagande i ditt arbetsträd.

Ta bort en spårad fil eller en katalog

Du kan använda git rm -f för att radera spårade filer i ditt arbetsträd. Observera dock att Git inte kan ta bort ospårade filer, eftersom det inte cachar dem.

Så här tar du bort en iscensatt fil:

git rm -f filename

Så här tar du bort en iscensatt mapp:

git rm -r -f foldername

Git -loggning

Så här visar du dina engagemangsloggar och historik i Git:

git log

Så här loggar du aktiviteterna i en specifik gren:

git log branch_name

Relaterad: Hur man inspekterar ett projekts historia med git -logg

Ibland kanske du vill återgå till ett övergivet åtagande. Så för att se övergivna åtaganden, inklusive de relevanta:

git reflog

Så här visar du ref -loggar för en viss gren:

git reflog branch_name

Hantera dina projektversioner som ett proffs med Git

Med Git som erbjuder många fördelar kan du fjärrhantera dina projektreleaser utan att blanda in filer och mappar på plats i din huvudgren. Dessutom kan du enkelt köra projekt med ett team.

Som du har sett har Git många funktioner som du kan utforska. Men var försiktig med att använda dessa funktioner målmedvetet. Annars kan du sluta bryta saker. Som sagt, du kan fortfarande snurra upp ett demo fjärrförråd och leka med dessa funktioner.

Dela med sig Dela med sig Tweet E-post Hantera din filversionering som en programmerare med Git

Programmerare skapade versionskontrollsystem (VCS) för att lösa problem med filversionskontroll. Låt oss titta på grunderna i versionskontroll med det bästa systemet idag, Git.

Läs Nästa Relaterade ämnen

Programmering
Webbutveckling
GitHub
Handledning för kodning

Om författaren Idisou Omisola(94 artiklar publicerade)

Idowu brinner för allt smart teknik och produktivitet. På fritiden leker han med kodning och byter till schackbrädet när han har tråkigt, men han älskar också att bryta sig från rutinen då och då. Hans passion för att visa människor vägen kring modern teknik motiverar honom att skriva mer.

Mer från Idowu Omisola

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera