Avanceret Git -vejledning

Avanceret Git -vejledning

Implementering af dit projekt via et fjernlager lader dig fleksibelt styre hver eneste bit af det. Fejlrettelser, funktionsopdateringer, sletning af filer, teamwork, open source-bidrag, kodedistribution og mere er nu lige ved hånden med et stærkt kendskab til Git.





Så du har brugt Git, men vil vide mere? Her er nogle mere avancerede Git -tips, der får din projektversionsstyring til at blive en leg.



Git gren

En Git -gren forhindrer dig i at skubbe direkte til hovedgrenen. Det er nyttigt, hvis du administrerer et projekt med et team af udviklere. Du kan oprette så mange Git -grene, som du vil, og derefter flette dem til hovedgrenen senere.





Opret en Git -gren

For at oprette en Git -gren skal du bruge:

git branch branch_name

Skift til en Git -gren

Brug checkout for at skifte til en Git -gren:



git checkout branch_name

Efter at have skiftet til en filial, kan du iscenesætte dine ændringer vha git tilføj -alle . Forplig dem derefter ved hjælp af git commit -m 'commit navn' kommando.

Sammenlign en gren med mester

Brug git diff kommando:



git diff master..branch_name

For at sammenligne specifikke filer:

git diff master..testb -- main.html

At sammenligne to grene ligner, hvordan du sammenligner en gren med masteren:



git diff branch1..branch2

Sådan ser du forskellene i en bestemt fil mellem to grene:

git diff branch1..branch2 -- main.html

Skub ændringer til en fjerngren

Du vil måske have en anden udvikler til at se på de ændringer, du har foretaget i en fil i din lokale afdeling, før han sender dem live. En god praksis er at skubbe din lokale Git -filial til en ekstern kopi, så de kan se det.

Lad os antage, at du tidligere har oprettet en lokal filial ved navn ændringer . Du kan skifte til den lokale filial, justere alle de filer, du vil have, derefter iscenesætte og overdrage dem til den gren.

Du kan derefter skubbe disse ændringer til fjernversionen af ​​grenen:

git push origin changes

Flet fjerngren med master ved hjælp af trækanmodning

Så en anden programmør har revideret ændringerne i fjerngrenen ( ændringer ). Men du vil fusionere det med hovedgrenen og skubbe den live.

Husk, at din fjerntliggende filial arver navnet på din lokale Git -filial ( ændringer ). Sådan fletter du ændringerne:

Skift til hovedgrenen:

git checkout master

Træk i grenens eller HOVEDET på grenen ( ændringer ) for at fusionere det med hovedgrenen:

git pull origin changes

Skub denne fletning live til hovedgrenen:

git push origin master

Brug Git Merge i stedet

For at flette en gren med master ved hjælp af gå kommando:

Migrer til hovedgrenen:

git checkout master

Flet det med grenen ( ændringer ):

git merge changes

Skub derefter fletningen live til hovedgrenen:

kan du se dine abonnenter på youtube
git push origin master

Sørg for, at du udskifter ændringer med navnet på din afdeling.

Når en fusion er vellykket, kan du derefter slette grenen lokalt og eksternt hvis du ikke har brug for det mere:

Relaterede: Sådan omdøber du en filial i Git

Git Rebase

Hvis du har flere grene med forældede forpligtelser, kan du genbasere eller omfokusere hoved/ref af disse grene til at arve hoved/ref af en opdateret.

Rebasing er derfor praktisk, når du skal opdatere nogle grene med bunden af ​​en nuværende.

Rebasing bør dog ikke være en hyppig handling, især hvis du arbejder med et team, da det kan forstyrre hele arbejdsgangen. Men hvis du arbejder alene, og du er fortrolig med din arbejdsgang og grene, bør rebasing ikke forårsage kaos, hvis du ved, hvor og hvordan du skal bruge det.

Antag f.eks., At du har to grene; gren1 og gren2. Nu har du ikke foretaget nogen ændringer i branch1 i nogen tid. Men du foretager konsekvent ændringer i branch2, herunder for nylig.

Så du besluttede at bære gren1 sammen med strømmen. Rebasing branch1 til branch2 betyder derfor, at du fortæller branch1 om at ignorere sine tidligere forpligtelser og arve den nylige forpligtelse til branch2.

Sådan kan du gøre det:

Skift til den forladte gren (gren1):

git checkout branch1

Genstart derefter gren1 til den opdaterede gren2:

git rebase branch2

Git Squash

Git squash lader dig flette flere forpligtelser til en. Det hjælper, når du løber git commit mange gange på en enkelt opdatering. Et praktisk eksempel er, når hver fejlrettelse eller koderefaktor for en enkelt funktion har en separat forpligtelse.

Men du vil måske ikke skubbe HEAD -forpligtelsen med de ledsagende, da de alle har det samme formål. En anbefalet fremgangsmåde er at klemme dem i én for at undgå forvirring, når sporing begås.

Den bedste måde at squash forpligter sig på er via den interaktive rebase -tilstand. Tag et kig på eksemplet herunder for at forstå dette bedre.

Antag i dette eksempel, at du har fem fejlrettelser. Og der er en forpligtelse for hver af dem. Sådan kan du squash disse fem forpligtelser til en:

Løb git reflog for at se hashkoden for dine forpligtelser:

git reflog

Her er resultatet i denne sag:

Nu er dit mål at squash de sidste fem forpligtelser, startende med første rettelse op til femte rettelse .

For at gøre det skal du kopiere hashkoden for forpligtelsen lige herunder første rettelse ( 0a83962 ). Tryk derefter på Q at afslutte refleks .

Kør nu git rebase -interaktiv på den hash.

git rebase --interactive 0a83962

Git åbner derefter en interaktiv rebase -fil, der ser sådan ud:

For at ødelægge forpligtelserne, eksklusive første rettelse , udskift plukke med s for hver af de andre forpligter:

Gem og luk denne fil.

En anden fil åbner derefter for dig at omdøbe den squashed commit:

bedste gratis film -app til Android

Rens dem, og indtast et foretrukket navn for den squashed commit:

Gem den fil. Luk den derefter, og du skal modtage en succesbesked i din terminal.

Bemærk: Den interaktive fil åbnes muligvis i terminalen. Men hvis du er på Windows, vil du måske tvinge din terminal til globalt at åbne filer til din foretrukne teksteditor for at gøre squashing let.

For at gøre det skal du åbne din kommandolinje og køre:

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

Git Fork vs. Git Clone

Forking og kloning er to forskellige udtryk i Git. Du kan ikke forkæle dit lager, da det allerede er der med dig. Du kan dog gaffle andres arkiv og klone det bagefter.

Forking et depot betyder, at du tager en kopi af en persons depot og gør det til dit. Når du får en kopi af det depot, kan du derefter klone det, som om du ville have gjort noget af dit git -lager til lokale ændringer.

Sådan gør du klone et fjernlager på GitHub, og start en download til dit lokale bibliotek:

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

Gendan en fil til dens standardtilstand

Hvis du vil slette ændringerne i en fil efter den sidste forpligtelse, kan du bruge git gendannelse kommando:

git restore filename

Ændre en forpligtelse

Du kan falde tilbage til en tidligere forpligtelse, hvis du glemmer at foretage ændringer i nogle filer, mens du opretter dem.

Foretag ændringer af den fil, du har glemt. Brug derefter git ændre for at gennemgå en forpligtelse:

git add file_forgotten
git commit --amend

Unstage -filer

Du kan fjerne bestemte filer, som du har iscenesat for en forpligtelse ved hjælp af gå rm kommando:

git rm --cached filename

Du kan også fjerne flere filer på én gang:

git rm --cached file1 file2 file3 file4

Husk at tilføje den relevante filtypenavn til enhver fil, du undtager. For eksempel skal en ren tekstfil være filnavn.txt .

Relaterede: Sådan rengøres Git og fjernes ikke -sporede filer

Git Nulstil

Ved brug af git nulstillet er nyttigt, hvis du vil slippe alle de filer, du har iscenesat for en forpligtelse på én gang:

git reset

Git reset HEAD peger dog HEADEN på en gren på en bestemt forpligtelse i dit arbejdstræ. For eksempel, hvis du endnu ikke har skubbet din nuværende forpligtelse, kan du falde tilbage til den for nylig skubbede forpligtelse:

git reset --soft HEAD~1

Erstatte --blød med --hårdt hvis du allerede har skubbet den nuværende forpligtelse:

git reset --hard HEAD~1

Gå tilbage

I modsætning til Nulstil kommando, gå tilbage opretholder integriteten af ​​din commit -historie. Det er praktisk, hvis du vil ændre en forpligtelse på grund af fejl eller fejl.

Det opgiver ikke målforpligtelsen eller laver en ny. I stedet vender det tilbage til de seneste ændringer, du foretager uden at slette eller omdøbe en sådan forpligtelse. Det er en fantastisk måde at holde dine forpligtelser renere, plus det er sikrere end at nulstille hele tiden.

For at vende tilbage til en forpligtelse:

git revert HEAD~1

Hvor HOVED ~ 1 peger på en bestemt forpligtelse i dit arbejdstræ.

Slet en sporet fil eller et bibliotek

Du kan bruge git rm -f for at slette alle sporede filer i dit arbejdstræ. Bemærk dog, at Git ikke kan fjerne usporede filer, da det ikke gemmer dem i cachen.

Sådan sletter du en iscenesat fil:

git rm -f filename

Sådan fjerner du en iscenesat mappe:

git rm -r -f foldername

Git -logning

Sådan får du vist dine forpligtelseslogfiler og historik i Git:

git log

Sådan logger du aktiviteterne i en bestemt gren:

git log branch_name

Relaterede: Sådan inspiceres et projekts historie med git -log

Nogle gange vil du måske vende tilbage til en forladt forpligtelse. Så for at se forladte forpligtelser, herunder de relevante:

git reflog

Sådan får du vist ref -logs for en bestemt gren:

git reflog branch_name

Administrer dine projektversioner som en proff med Git

Med Git, der tilbyder mange fordele, kan du fjernadministrere dine projektudgivelser uden at indbrudse filer og mapper på stedet i din hovedgren. Derudover lader det dig nemt køre projekter med et team.

Som du har set, har Git mange funktioner, som du kan udforske. Men vær forsigtig med at bruge disse funktioner målrettet. Ellers kan du ende med at bryde ting. Når det er sagt, kan du stadig spinde et demo -fjernlager op og lege med disse funktioner.

Del Del Tweet E -mail Administrer din filversionering som en programmerer med Git

Programmerere oprettede versionskontrolsystemer (VCS) for at løse problemer med filversionskontrol. Lad os se på det grundlæggende i versionskontrol ved hjælp af det øverste system i dag, Git.

Læs Næste Relaterede emner
  • Programmering
  • Web-udvikling
  • GitHub
  • Kodning Tutorials
Om forfatteren Idisou Omisola(94 artikler udgivet)

Idowu brænder for alt smart teknologi og produktivitet. I fritiden leger han med kodning og skifter til skakbrættet, når han keder sig, men han elsker også at bryde væk fra rutinen en gang imellem. Hans passion for at vise folk vejen rundt om moderne teknologi motiverer ham til at skrive mere.

Mere fra Idowu Omisola

Abonner på vores nyhedsbrev

Tilmeld dig vores nyhedsbrev for at få tekniske tips, anmeldelser, gratis e -bøger og eksklusive tilbud!

Klik her for at abonnere