Avansert Git -opplæring

Avansert Git -opplæring

Ved å distribuere prosjektet ditt via et eksternt depot kan du fleksibelt administrere alle deler av det. Feilrettinger, funksjonsoppdateringer, sletting av filer, teamarbeid, åpen kildekode-bidrag, kodedistribusjon og mer er nå tilgjengelig for deg med sterk kunnskap om Git.





Så du har brukt Git, men vil vite mer? Her er noen mer avanserte Git -tips som vil gjøre prosjektversjonskontrollen en lek.



Git gren

En Git -gren hindrer deg i å skyve direkte til hovedgrenen. Det er nyttig hvis du administrerer et prosjekt med et team av utviklere. Du kan opprette så mange Git -grener du vil, og deretter slå dem sammen med hovedgrenen senere.





Lag en Git -gren

For å opprette en Git -gren, bruk:

git branch branch_name

Bytt til en Git -gren

Bruk Sjekk ut for å bytte til en Git -gren:



git checkout branch_name

Etter å ha byttet til en filial, kan du gjøre endringene dine med git add -alt . Forplikt dem deretter til å bruke git commit -m 'commit name' kommando.

Sammenlign en gren med master

Bruke git diff kommando:



git diff master..branch_name

For å sammenligne spesifikke filer:

git diff master..testb -- main.html

Å sammenligne to grener ligner på hvordan du sammenligner en gren med masteren:



git diff branch1..branch2

For å se forskjellene i en bestemt fil mellom to grener:

git diff branch1..branch2 -- main.html

Skyv endringer til en ekstern gren

Du vil kanskje at en annen utvikler skal se på endringene du har gjort i en fil i din lokale gren før du sender dem live. En god praksis er å skyve din lokale Git -gren til en ekstern kopi, slik at de kan se på.

La oss anta at du tidligere har opprettet en lokal filial ved navn Endringer . Du kan bytte til den lokale grenen, justere alle filene du vil ha, deretter sette opp og forplikte dem til den grenen.

Du kan deretter skyve disse endringene til den eksterne versjonen av grenen:

git push origin changes

Slå sammen ekstern gren med master ved hjelp av Pull Request

Så en annen programmerer har revidert endringene i den eksterne grenen ( Endringer ). Men du vil slå den sammen med hovedgrenen og skyve den live.

Husk at den eksterne grenen din arver navnet på din lokale Git -gren ( Endringer ). Slik slår du sammen endringene:

Bytt til hovedgrenen:

git checkout master

Trekk grenenes opprinnelse eller HEAD ( Endringer ) for å slå den sammen med hovedgrenen:

git pull origin changes

Skyv denne sammenslåingen live til hovedgrenen:

git push origin master

Bruk Git Merge i stedet

For å slå sammen en gren med master ved hjelp av gå kommando:

Migrer til hovedgrenen:

git checkout master

Slå det sammen med grenen ( Endringer ):

git merge changes

Skyv deretter sammenslåingen live til hovedgrenen:

gratis filmstrømming uten registrering
git push origin master

Sørg for at du bytter ut Endringer med navnet på grenen din.

Når en sammenslåing er vellykket, kan du gjøre det slett grenen lokalt og eksternt hvis du ikke trenger det lenger:

I slekt: Hvordan gi nytt navn til en gren i Git

Git Rebase

Hvis du har flere grener med utdaterte forpliktelser, kan du rebase eller refokusere hode/ref av disse grenene for å arve hode/ref av en oppdatert.

Rebasing er derfor nyttig når du trenger å oppdatere noen grener med basen til en nåværende.

Rebasing bør imidlertid ikke være en hyppig handling, spesielt hvis du jobber med et team, da det kan forstyrre hele arbeidsflyten. Men hvis du jobber alene og er kjent med arbeidsflyten og grener, bør rebasing ikke skape ødeleggelse hvis du vet hvor og hvordan du bruker den.

Anta for eksempel at du har to grener; gren1 og gren2. Nå har du ikke gjort noen endringer i branch1 på en stund. Men du foretar konsekvent endringer i branch2, inkludert nylig.

Så du bestemte deg for å bære gren1 sammen med strømmen. Å omgrene gren1 til gren2 betyr derfor at du forteller gren1 om å ignorere sine tidligere forpliktelser og arve den siste forpliktelsen som ble gjort til gren2.

Slik kan du gjøre det:

Bytt til den forlatte grenen (gren1):

git checkout branch1

Rebase deretter gren1 til den oppdaterte grenen2:

git rebase branch2

Git Squash

Git squash lar deg slå sammen flere forpliktelser til en. Det hjelper når du løper git commit mange ganger på en enkelt oppdatering. Et praktisk eksempel er når hver feilrettelse eller koderefaktor for en enkelt funksjon har en egen forpliktelse.

Men du vil kanskje ikke skyve HEAD -forpliktelsen med de medfølgende, ettersom de alle har samme formål. En anbefalt tilnærming er å klemme dem inn i en for å unngå forvirring når du sporer forpliktelser.

Den beste måten å forplikte seg på er via den interaktive rebase -modusen. Ta en titt på eksemplet nedenfor for å forstå dette bedre.

Anta i dette eksemplet at du har fem feilrettinger. Og det er en forpliktelse for hver av dem. Slik kan du squash disse fem forpliktelsene til en:

Løpe git reflog for å se hashkoden til dine forpliktelser:

git reflog

Her er resultatet i denne saken:

Nå er målet ditt å squash de fem siste forpliktelsene, fra og med første løsning opp til femte løsning .

For å gjøre det, kopier hashkoden til forpliktelsen like nedenfor første løsning ( 0a83962 ). Trykk deretter på Sp å slutte refleks .

Nå løp git rebase -interaktiv på den hashen.

git rebase --interactive 0a83962

Git åpner deretter en interaktiv rebase -fil som ser slik ut:

For å knuse forpliktelsene, unntatt første løsning , erstatte plukke med s for hver av de andre forplikter seg:

Lagre og lukk denne filen.

En annen fil åpnes deretter for at du kan gi nytt navn til den squashed commit:

hvordan lage en emoji på iphone

Rengjør disse og skriv inn et foretrukket navn for den klemte forpliktelsen:

Lagre den filen. Lukk den og du bør motta en suksessmelding i terminalen din.

Merk: Den interaktive filen kan åpne i terminalen. Men hvis du er på Windows, vil du kanskje tvinge terminalen til å åpne filer globalt til din favoritt tekstredigerer for å gjøre squashingen enkel.

For å gjøre det, åpne kommandolinjen og kjør:

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

Git Fork vs. Git Clone

Gaffel og kloning er to forskjellige termer i Git. Du kan ikke forkaste depotet ditt, ettersom det allerede er der. Du kan imidlertid forkle andres depot og klone det etterpå.

Gaffel et depot betyr at du tar en kopi av noens depot og gjør det til ditt. Når du har fått en kopi av det depotet, kan du deretter klone det som om noen av dine git -lagre for lokale endringer.

Slik gjør du det klone et eksternt depot på GitHub og start en nedlasting til din lokale katalog:

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

Gjenopprett en fil til standardtilstanden

Hvis du vil slette endringene i en fil etter den siste forpliktelsen, kan du bruke git -gjenoppretting kommando:

git restore filename

Endre en forpliktelse

Du kan falle tilbake til en tidligere forpliktelse hvis du glemmer å gjøre endringer i noen filer mens du lagrer dem.

Gjør endringer i filen du har glemt. Deretter bruker du git endre å gjennomgå en forpliktelse:

git add file_forgotten
git commit --amend

Unstage -filer

Du kan fjerne bestemte filer som du har iscenesatt for en forpliktelse ved å bruke gå rm kommando:

git rm --cached filename

Du kan også fjerne flere filer samtidig:

git rm --cached file1 file2 file3 file4

Husk å legge den relevante filtypen til alle filer du unntar. For eksempel bør en ren tekstfil være filnavn.txt .

I slekt: Slik rengjør du Git og fjerner ikke -sporede filer

Git Reset

Ved hjelp av git reset er nyttig hvis du vil slippe alle filene du har iscenesatt for en forpliktelse samtidig:

git reset

Git reset HEAD peker imidlertid HEADEN på en gren til en bestemt forpliktelse i arbeidstreet ditt. For eksempel, hvis du ennå ikke har presset din nåværende forpliktelse, kan du falle tilbake til den nylig pressede forpliktelsen:

git reset --soft HEAD~1

Erstatte --myk med --hard hvis du allerede har presset gjeldende forpliktelse:

git reset --hard HEAD~1

Gå tilbake

i motsetning til nullstille kommando, gå tilbake opprettholder integriteten til din commit -historie. Det er nyttig hvis du vil endre en forpliktelse på grunn av feil eller feil.

Det forlater ikke målforpliktelsen eller lager en ny. I stedet går den tilbake til de siste endringene du gjør uten å slette eller gi nytt navn til en slik forpliktelse. Det er en fin måte å holde dine forpliktelser renere, pluss at det er tryggere enn å tilbakestille hele tiden.

For å gå tilbake til en forpliktelse:

git revert HEAD~1

Hvor HEAD ~ 1 peker på en bestemt forpliktelse i arbeidstreet.

Slett en sporet fil eller en katalog

Du kan bruke git rm -f for å slette alle sporede filer i arbeidstreet. Vær imidlertid oppmerksom på at Git ikke kan fjerne filer som ikke er sporet, da de ikke lagrer dem i bufferen.

Slik sletter du en iscenesatt fil:

git rm -f filename

Slik fjerner du en iscenesatt mappe:

git rm -r -f foldername

Git Logging

Slik ser du forpliktelseslogger og historikk i Git:

git log

Slik logger du aktivitetene i en bestemt gren:

git log branch_name

I slekt: Slik inspiserer du et projekts historie med git -logg

Noen ganger vil du kanskje gå tilbake til en forlatt forpliktelse. Så for å se forlatte forpliktelser, inkludert de relevante:

git reflog

Slik viser du ref -logger for en bestemt gren:

git reflog branch_name

Administrer prosjektversjonene dine som en proff med Git

Med Git som tilbyr mange fordeler, kan du administrere prosjektutgivelsene eksternt uten å rase inn filer og mapper på stedet i hovedgrenen din. I tillegg lar du deg enkelt kjøre prosjekter med et team.

Som du har sett, har Git mange funksjoner du kan utforske. Men vær forsiktig med å bruke disse funksjonene målrettet. Ellers kan du ende opp med å bryte ting. Når det er sagt, kan du fortsatt spinne opp et demo -eksternt depot og leke med disse funksjonene.

Dele Dele kvitring E -post Administrer filversjonen din som en programmerer med Git

Programmerere opprettet versjonskontrollsystemer (VCS) for å løse problemer med filversjonskontroll. La oss se på det grunnleggende om versjonskontroll ved hjelp av det øverste systemet i dag, Git.

Les neste Relaterte temaer
  • Programmering
  • Webutvikling
  • GitHub
  • Opplæringsprogrammer for koding
Om forfatteren Idisou Omisola(94 artikler publisert)

Idowu brenner for alt smart teknologi og produktivitet. På fritiden leker han med koding og bytter til sjakkbrettet når han kjeder seg, men han liker også å bryte fra rutinen en gang i blant. Hans lidenskap for å vise folk veien rundt moderne teknologi motiverer ham til å skrive mer.

Mer fra Idowu Omisola

Abonner på vårt nyhetsbrev

Bli med i vårt nyhetsbrev for tekniske tips, anmeldelser, gratis ebøker og eksklusive tilbud!

Klikk her for å abonnere