Topp 10 essensielle Git -kommandoer

Git har blitt det viktigste versjonskontrollsystemet. Fremveksten av Gits popularitet kan tilskrives dens hastighet, smidighet og allsidighet. Enten du er en frilansende nettutvikler eller programvaredesigner for applikasjoner på bedriftsnivå, kan du dra nytte av å bruke GIT. Det hjelper deg å holde rede på filene dine gjennom systematisk versjonering. Git gjør det lettere å rulle tilbake til eldre versjoner av kode eller lage nye grener for å eksperimentere på den nåværende kodebasen. Git er også et distribuert versjonskontrollsystem som betyr at du ikke alltid trenger å koble deg til en sentral server for å få arbeidet ditt gjort.Nedenfor er de essensielle GIT-kommandoene som vil hjelpe i dine daglige oppgaver. De enkle eksemplene vil gi deg en forståelse av kommandoene, slik at du enkelt kan huske syntaksen når du trenger å bruke dem.

1. git add

GIT Add -kommandoen lar deg begynne å spore filer og mapper for Git -depotet ditt og flytter dem til iscenesettelsesområdet. Du må bruke Git Commit -kommandoen for å gjøre dem permanente på dine historiske øyeblikksbilder.

Å bruke kommandoen er enkelt. Du kan velge å legge til filer og mapper individuelt eller bruke Linux Type Asterisk (*) Glob -operatør for å legge dem til i grupper.

La oss ta eksemplet nedenfor:

Anta at vi i ovennevnte tilfelle allerede har lagt til readme.tekst. Men resten av filene er ikke lagt til.

La oss sjekke statusen:

$ git status
På grenmester
Filialen din er oppdatert med 'Origin/Master'.
Ikke -sporede filer:
(Bruk 'git add ...' for å inkludere i det som vil bli begått)
fil1.tekst
File2.tekst
mappe1/

Filene og mappene er i rødt, noe som betyr at de ikke blir sporet. Vi kan legge dem til ved hjelp av:

$ git Legg til File1.TXT File2.txt Folder1/*

Hvis vi sjekker statusen nå:

$ git status
På grenmester
Filialen din er oppdatert med 'Origin/Master'.
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Ny fil: File1.tekst
Ny fil: File2.tekst
Ny fil: mappe1/file3.tekst
Ny fil: Folder1/File4.tekst

GIT ADD -kommandoen har lagt filene til iscenesettelsesområdet. Filer holdes i iscenesettelsesområdet før de gjør dem permanente gjennom forpliktelsesprosessen.

2. git gren

På git er forgrening enkelt. I andre versjonskontrollsystemer var det en dyr operasjon. Men Git -algoritmer er optimalisert for forgrening. Så du kan bruke GIT -grenkommandoen når du vil lage en egen utviklingslinje uten å bekymre deg for ytelse.

La oss se på følgende eksempel.

$ git status
På grenmester
Filialen din er oppdatert med 'Origin/Master'.
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Ny fil: File1.tekst
Ny fil: File2.tekst
Ny fil: mappe1/file3.tekst
Ny fil: Folder1/File4.tekst

Legg merke til at vi er 'på filialmester'. Når du oppretter et nytt prosjekt, havner du i Branch Master. Du kan også bruke GIT -grenen -en kommando for å finne ut hvilken gren du er på:

$ git gren -a
* mester

Ovennevnte forteller deg at det bare er en gren som heter 'Master' og stjerne (*) betyr at du er på den grenen.

La oss lage en ny gren som heter 'Testing':

$ git gren testing

Nå kan vi sjekke grenene igjen:

$ git gren -a
* mester
testing

Selv om vi fremdeles er på 'master' grenen, kan vi også se den nye 'testing' -grenen som ble opprettet. 'Testing' -grenen er en kopi av 'master' grenen.

3. Git Checkout

Git -kassekommandoen tar deg til en gren, slik at du kan jobbe med ressursene der inne. Du kan tenke på grener som elver og bekker. Med en gren oppretter du en ny strøm. Med kassekommandoen flytter du inn i den strømmen.

La oss sjekke grenen 'Testing' fra forrige eksempel:

$ git kassetesting
Byttet til gren 'testing'

La oss nå sjekke statusen og grenene igjen:

$ git status
På grenetesting
Ingenting å begå, arbeidskatalog ren
$ git gren -a
herre
* Testing

Du kan se fra Git -grenen -en kommando som vi har flyttet til testgrenen.

4. git klon

Git Clone -kommandoen lar deg lage en kopi av ethvert Git -depot. Så snart du kloner et depot, vil den nye klonede mappen begynne å holde oversikt over endringer lokalt. Fordi Git er distribuert, er en klon et fullt autonomt git -depot.

For å vise hvordan kloning fungerer, la oss lage et nytt depot:

$ mkdir dir1
$ CD DIR1
$ MKDIR MyProject
$ CD MyProject/
$ git init
Initialisert tomt Git -depot i/Dir1/MyProject/.git/
$ Touch Readme.tekst
$ git commit -m 'initialiser mitt depot'
[Master (Root-Commit) 5A0BD75] Initialiser mitt depot
1 Fil endret, 0 innsettinger (+), 0 delesjoner (-)
Opprett modus 100644 Readme.tekst

I eksemplet ovenfor har vi opprettet Git Repository kalt 'MyProject' Inside 'Dir1' -mappen. Anta at dette er vårt viktigste depot. Nå vil vi lage en kopi av den og jobbe andre steder.

La oss lage en katalog som heter 'Dir2' og klone 'MyProject' -depotet. Vi bruker Git -klonen for å klone 'MyProject':

$ mkdir dir2
$ CD DIR2
$ git klon/dir1/myproject/
Kloning til 'myprosjekt' ..
Ferdig.
$ ls
mitt prosjekt

Git -klonekommandoen fungerer også med en URL.

$ git klon https: // github.com/test/test.git

Du kan også endre navnet på klonen ved å spesifisere den etter Git -depotadressen:

$ git klon https: // github.com/test/test.git myTest

5. git forpliktelse

Git Commit -kommandoen kjøres etter GIT -tilleggskommandoen. I vårt Git -eksempel hadde vi lagt til filene for sporing, men vi hadde ikke forpliktet det til Git -depotet. Sporing forblir lokal til en forpliktelse er utført. Når du begår endringene, blir de en del av den faste posten.

Nedenfor kjører vi Git Commit -m -kommandoen:

$ git commit -m 'å begå mine filer og mapper'
[Master 3ef57b3] Å begå mine filer og mapper
4 filer endret, 0 innsettinger (+), 0 slettinger (-)
Opprett modus 100644 File1.tekst
Opprett modus 100644 File2.tekst
Opprett modus 100644 mappe1/file3.tekst
Opprett modus 100644 Folder1/File4.tekst

Hvis du ikke bruker alternativet -m til å legge en kommentar, vil Git åpne standard tekstredigerer og be om den. Kommentarer anses som god versjonskontrollpraksis. Så legg alltid meningsfulle kommentarer i din forpliktelse.

6. git config

GIT Config -kommandoen lar deg sette opp forskjellige alternativer for Git -depotet ditt. For eksempel kan du bruke Git -konfigurasjonskommandoen for å få og angi brukeren din.navn og bruker.e -post.

Slik kan du angi verdiene:

$ git config -global bruker.Navn 'Zak H'
$ git config -global bruker.E -post [email protected]

Slik kan du sjekke verdiene:

$ git config -global bruker.Navn
Zak h
$ git config -global bruker.e -post
[email protected]

7. git diff

GIT DIFF -kommandoen hjelper deg med å se forskjellene mellom filer og mapper. Hvis du gjør endringer i en fil, er det et nyttig verktøy for raskt å evaluere endringene du har gjort.

La oss anta at vi starter arbeidet vårt med en readme.txt -fil med to linjer. Så blir vi kvitt den andre linjen og legger til en tredje linje.

Hvis vi kjører diff -kommandoen, vil den vise forskjellene mellom den engasjerte versjonen og den lokale endrede versjonen i iscenesettelsesområdet. Slik vil det se ut:

$ git diff
Diff -Git A/Readme.txt b/readme.tekst
Indeks 9475DDC… 1804904 100644
--- a/readme.tekst
+++ b/readme.tekst
@@ -1,2 +1,2 @@
Linje 1: Min første linje
-Linje 2: Min andre linje
+Linje 3: Min tredje linje

Linje 1 er uendret (hvit), linje 2 fjernet (rød) og linje 3 lagt til (grønn).
Du kan bruke diff -kommandoen til også å finne forskjeller mellom spesielle forpliktelser.

8. git hente

Git Fetch -kommandoen får de nyeste ressursene fra det spesifiserte opprinnelsen.

La oss se på et eksempel. Antatt at du har følgende tilstand:

Dir1/MyProject
Dir2/MyProject (klonet)

Mappen 'Dir2/MyProject' er klonet fra 'Dir1/MyProject'. Hvis noen begikk endringer i 'Dir1/MyProject', kan du få de endringene som dette fra innsiden 'Dir2/MyProject':

$ git hente opprinnelse
Fjern: Teller objekter: 2, gjort.
Fjern: Komprimerende objekter: 100% (2/2), gjort.
Fjern: Totalt 2 (Delta 0), gjenbrukt 0 (Delta 0)
Pakk ut objekter: 100% (2/2), gjort.
Fra /Dir2 /… /Dir1 /MyProject
5A0BD75… 1713734 Master -> Origin/Master

Det er viktig å huske at Git Fetch -kommandoen ikke slår sammen endringene. For automatisk henting og smelte sammen, bruk Git Pull -kommandoen. Da lurer du kanskje på hvorfor bruk denne kommandoen i utgangspunktet. Det kan være avanserte GIT -alternativer der du får alle endringene fra Origin Server og deretter bare bruke endringer selektivt på visse filer. Git Fetch -kommandoen lar deg oppnå dette. Imidlertid er det et avansert tema du kan finne i Git Fetch -dokumentasjonen.

9. git grep

Git grep -kommandoen lar deg søke i git -treet ditt etter informasjon. Her er eksempel på å søke på ordet 'linje' i vårt git -depot. Alternativet -n eller -linjentall viser linjenumre der Git finner en kamp:

$ git grep -n linje
Readme.TXT: 1: Linje 1: Min første linje
Readme.TXT: 2: Linje 3: Min tredje linje

Du kan kjøre et lignende søk etter antall ganger kampen er der med -c eller --tellende alternativet:

git grep -c linje
Readme.txt: 2

Årsaken til å bruke git grep over Linux grep er at git grep er raskere for git -depoter.

10. git log

Git -log -kommandoen viser deg forpliktelseshistorikken.

$ git log
Commit 171373479FC309846EF605FBE650933767AFD0FB
Forfatter: Zak H
Dato: ons 21. november 20:26:32 2018 -0800
Nye filer lagt til
forpliktelse 5A0BD759506D20B2B989873258BF60D003AA3D36
Forfatter: Zak H
Dato: ons 21. november 18:48:35 2018 -0800
Initialiser mitt depot

Du kan også bruke alternativet --oneline til å se en forkortet versjon. Den forkortede versjonen er lettere å følge.

$ git log --oneline
1713734 Nye filer lagt til
5A0BD75 Initialiser mitt depot

11. git smelte

Git Merge -kommandoen fusjonerer grener.

La oss lage et nytt depot med 'hoved' og deretter opprette en 'test' gren.

$ MKDIR MyProject
$ CD MyProject
$ git init
Initialisert tom git repository in/git_essentials/myproject/.git/
$ Touch Readme.tekst
$ git add -a
$ git commit -m 'initial commit'
[Master (Root-Commit) B31D4E1] Innledende forpliktelse
1 Fil endret, 0 innsettinger (+), 0 delesjoner (-)
Opprett modus 100644 Readme.tekst
$ git gren test
$ git gren -a
* mester
test
$ Git Checkout Test
Byttet til gren 'test'

La oss gjøre noen endringer i "Test" -grenen ":

$ Touch File1.TXT File2.tekst
$ Ls
Fil1.TXT File2.txt readme.tekst
$ git add -a
$ git commit -m 'Lagt til to nye filer'
[Test 7E11910] Lagt til to nye filer
2 filer endret, 0 innsettinger (+), 0 slettinger (-)
Opprett modus 100644 File1.tekst
Opprett modus 100644 File2.tekst

Vi har lagt til to filer på prøve.

$ git gren -a
herre
* Test
$ ls
Fil1.TXT File2.txt readme.tekst
$ git Checkout Master
Byttet til filial 'master'
$ git gren -a
* mester
test
$ ls
Readme.tekst

Vi ser fra ovennevnte, den filen1.TXT og File2.TXT eksisterer i 'test' gren, men ikke i 'master'.

La oss slå sammen nå.

$ git fusjonstest
Oppdatering av B31D4E1 ... 7E11910
Spol fremover
Fil1.txt | 0
File2.txt | 0
2 filer endret, 0 innsettinger (+), 0 slettinger (-)
Opprett modus 100644 File1.tekst
Opprett modus 100644 File2.tekst
$ ls
Fil1.TXT File2.txt readme.tekst
$ git gren -a
* mester
test

Nå har vi 'File1.txt 'og' File2.txt 'i' master 'gren også.

Merk: Tenk på å slå seg sammen som en trekkoperasjon. Du må være i grenen du vil slå sammen til. I dette tilfellet er du i 'master' grenen og trekker endringene fra 'test' grenen.

12. git mv

Git MV er en snarvei -kommando for å kjøre git add og git rm -kommandoer. Det kan brukes til å gi nytt navn til filer.

Her er et eksempel:

$ git mv readme.txt readme.MD
$ git status
På grenmester
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Omdøpt: Readme.txt -> readme.MD

1. 3. git pull

Git -trekk -kommandoen er mye som Git -hente, bortsett fra at sammenslåingen automatisk skjer.

Her er et eksempel på å kjøre Git Pull Origin som Git Fetch One (vi kjører en trekkforespørsel fra klonen for å få endringer fra det originale Git -depotet):

$ git pull opprinnelse
Fjern: Teller objekter: 3, gjort.
Fjern: Komprimerende objekter: 100% (2/2), gjort.
Fjern: Totalt 3 (Delta 0), gjenbrukt 0 (Delta 0)
Pakk ut objekter: 100% (3/3), gjort.
Fra/learngit/git_essentials/myproject
7e11910… E67F932 Master -> Origin/Master
Oppdatering 7E11910… E67F932
Spol fremover
Fil1.txt | 1 +
File2.txt | 1 +
File3.txt | 1 +
Readme.txt => readme.MD | 0
4 filer endret, 3 innsettinger (+)
Opprett modus 100644 File3.tekst
Gi nytt navn til Readme.txt => readme.MD (100%)

Du kan se at endringer er lastet ned fra opprinnelsen og slått seg sammen til klonen.

14. git push

Git Push -kommandoen brukes til å skyve endringer til eksterne depoter. Her er et eksempel på å kjøre push -kommandoen:

$ git push origin master
Teller objekter: 2, gjort.
Delta -komprimering ved bruk av opptil 4 tråder.
Komprimerende objekter: 100% (2/2), gjort.
Skrive objekter: 100% (2/2), 242 byte | 0 byte/s, gjort.
Totalt 2 (Delta 1), gjenbrukt 0 (Delta 0)
Til/learngit/git_essentials/myproject
E67F932 ... 90DC546 Master -> Master

Git Push Origin Master -kommandoen sender endringer til 'Master' grenen av opprinnelsen (Git -depotet du klonet) fra 'Master' grenen av det klonede depotet. Visuelt ser push slik ut:

Cloned/Master -> Origin/Master

15. git rebase

GIT REBASE -kommandoen hjelper deg med å endre basen til grenene. I en generell sammenslåing skjer det noe slikt:

Testgrenen er slått sammen til 'master' grenen for å skape en ny forpliktelse.

I en rebase er det dette som skjer:

Endringene fra E- og F -endringslisten er beregnet på nytt og festet på slutten av mastergrenen. Rebasering hjelper til med å forenkle grenene.

La oss anta at vi har denne situasjonen i 'master' grenen:

$ git log --oneline
7F573D8 Commit C: Lagt til C.tekst
795da3c forpliktelse b: lagt til b.tekst
0f4Ed5b forplikte a: Lagt til en.tekst

Og en funksjonsgren:

$ git log --oneline
8ed0c4e forpliktelse f: modifisert b.tekst
6e12b57 forpliktelse e: modifisert a.tekst
795da3c forpliktelse b: lagt til b.tekst
0f4Ed5b forplikte a: Lagt til en.tekst

Hvis vi rebase, får vi Git Rebase Master:

$ git kassafunksjon
Byttet til gren 'funksjon'
$ git rebase master

Først spolte hodet for å spille av arbeidet ditt på toppen av det ..

Bruker: forpliktelse e: modifisert a.tekst
Bruker: forplikte f: modifisert b.tekst
Deretter slå sammen 'funksjonen' til 'master'.
$ git Checkout Master
Byttet til filial 'master'
$ git fusjonsfunksjon
Oppdatering 7F573D8 ... 9EFA1A3
Spol fremover
en.txt | 1 +
b.txt | 1 +
2 filer endret, 2 innsettinger (+)

Hvis du nå går til både 'Master' og 'Feature' -grenen, vil du se de samme tømmerstokkene:

$ git log --oneline
9efa1a3 forpliktelse f: modifisert b.tekst
8710174 forpliktelse e: modifisert a.tekst
7F573D8 Commit C: Lagt til C.tekst
795da3c forpliktelse b: lagt til b.tekst
0f4Ed5b forplikte a: Lagt til en.tekst

Ombasering har klemt dem sammen.

Merk: Bruk aldri rebasering i offentlige depoter, da utviklere vil støte på store sammenslåingsspørsmål.

git fjernkontroll

Git -ekstern -kommandoen lar deg angi en ekstern server for depotet ditt. I en kloningssituasjon blir kildelageret automatisk fjernkontrollen.

For eksempel:

$ pwd
/Learngit/git_essentials/test
$ git ekstern -v
Origin/LearnGit/git_essentials/MyProject (henter)
Origin/LearnGit/git_essentials/MyProject (Push)

Ovennevnte viser at den eksterne serveren for 'test' er en annen mappe som heter 'MyProject'. Årsaken er at 'test' ble klonet for prosjektet mitt.

Men den eksterne serveren trenger ikke å være lokal. Du kan ha noe slikt med en URL:

$ git ekstern -v
Origin https: // github.com/zakh/myproject (henter)
Origin https: // github.com/zakh/myproject (push)

Du kan sette opp et GIT eksternt depot ved hjelp av kommandoen Git Remote Legg til:

$ git eksternt legg til opprinnelse https: // github.com/zakh/myproject

Dette vil koble repoen din til opprinnelsen slik at du kan hente og skyve.

17. Git tilbakestilling

GIT -tilbakestillingen lar deg ufastere lagt til filer.

La oss si at du la til filtesten.txt 'til depotet ditt:

$ berøringstest.tekst
$ git add -a
$ git status
På grenmester
Filialen din er oppdatert med 'Origin/Master'.
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Ny fil: Test.tekst

Du bestemmer deg imidlertid for at du ikke vil spore 'test.txt 'lenger. Du kan bruke GIT Reset Head -kommandoen for å fjerne filen:

$ git reset head test.tekst

Hvis du sjekker statusen, er filen igjen ikke sporet:

$ git status
På grenmester
Filialen din er oppdatert med 'Origin/Master'.
Ikke -sporede filer:
(Bruk 'git add ...' for å inkludere i det som vil bli begått)
test.tekst

Filen 'testen.txt 'spores ikke lenger.

18. git tilbake

GIT REVERT -kommandoen lar deg reversere endringer ved hjelp av Commit Hash -nummeret.

$ ekko 'test 1' >> myfile.tekst
$ git add -a
$ git commit -m 'lagt til endring 1'
[Master 78a8277] Lagt til endring 1
2 filer endret, 1 innsetting (+)
Opprett modus 100644 myfile.tekst
Opprett modus 100644 Test.tekst
$ katt myfile.tekst
Test 1
$ ekko 'test 2' >> myfile.tekst
$ git add -a
$ git commit -m 'lagt til endring 2'
[Master A976E9C] Lagt til endring 2
1 Fil endret, 1 innsetting (+)
$ katt myfile.tekst
Test 1
Test 2
$ git log --oneline
a976e9c lagt til endring 2
78A8277 lagt til endring 1
90dc546 la til en fil
E67F932 la til nye filer
7e11910 la til to nye filer
B31D4E1 innledende forpliktelse

Vi opprettet en 'myfil.txt 'og begikk to endringer, så filen har linjene' Test 1 'og' Test 2 '. Men vi bestemte oss for at vi ikke vil ha den andre forpliktelsen. Så vi fant Commit Hash (A976E9C) for det. Vi kan bruke Git -tilbakevendingen for å bli kvitt forpliktelsen:

$ git tilbake A976E9C
[Master 4F270E7] REVERT 'Lagt til endring 2'
1 fil endret, 1 sletting (-)
$ git log --oneline
4F270E7 REVERT 'lagt til endring 2'
a976e9c lagt til endring 2
78A8277 lagt til endring 1
90dc546 la til en fil
E67F932 la til nye filer
7e11910 la til to nye filer
B31D4E1 innledende forpliktelse
$ katt myfile.tekst
Test 1

Vi ser at det ble opprettet en ny forpliktelse som ble opprettet som tilbakeførte 'Test 2' -linjens forpliktelse. Filen har bare 'Test 1' -linjen nå.

19. git rm

Git RM -kommandoen setter opp filer for fremtidige slettinger. Det setter filene som skal-bli-slettet i iscenesettelsesområdet.

$ git rm test.tekst
RM 'test.tekst'
$ git status
På grenmester
Filialen din er foran 'Origin/Master' med 3 forpliktelser.
(Bruk 'git push' for å publisere dine lokale forpliktelser)
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Slettet: Test.tekst

Du må begå endringene for at sleten skal tre i kraft.

20. git stash

Git Stash -kommandoen lar deg midlertidig forlate arbeidet du ikke er klar til å forplikte deg ennå.
Anta at du jobber i et depot med følgende filer:

$ ls
John.txt Mary.tekst
Du vil endre disse filene for å være mer prosjektbasert. Så du begynner med:
$ git mv John.TXT ProjectFile1.tekst
$ ls
Mary.TXT ProjectFile1.tekst
$ git status
På grenmester
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Omdøpt: John.TXT -> ProjectFile1.tekst

Midt i å gi nytt navn og oppdatere 'John.txt 'til' ProjectFile1.txt ', du mottar en forespørsel om å endre noe i prosjektet. Men du er ikke klar til å sende inn 'ProjectFile1.tekst'. Så du stash det.

$ git stash

Lagret arbeidskatalog og indeksstat WIP på Master: F0B5A01 Init John og Mary

Hodet er nå på F0B5A01 init John og Mary

$ ls
John.txt Mary.tekst

Det lokale arbeidsmiljøet ditt er tilbake til der du var før du gjorde dine prosjektbaserte endringer. Etter å ha ivaretatt avbruddet, i stedet for å gå tilbake til 'John.txt ', du bestemmer deg for å jobbe med' Mary.txt 'fil nå:

$ git mv Mary.TXT ProjectFile2.tekst
$ git status
På grenmester
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Omdøpt: Mary.TXT -> ProjectFile2.tekst
$ ls
John.TXT ProjectFile2.tekst

Du blir avbrutt igjen og du stash det nye arbeidet ditt med 'Mary.tekst':

$ git stash
Lagret arbeidskatalog og indeksstat WIP på Master: F0B5A01 Init John og Mary
Hodet er nå på F0B5A01 init John og Mary
$ ls
John.txt Mary.tekst

Etter at avbruddsarbeidet er utført, sjekker du Stash -listen:

$ git stash liste
stash@0: wip on master: f0b5a01 init John and Mary
stash@1: wip on master: f0b5a01 init John and Mary

Du har to arbeids-i-progress (WIP) i stashen. Firs tid du spretter stash, du får den siste 'Mary.TXT 'Endringer:

$ git stash pop
Fjerne Mary.tekst
På grenmester
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Ny fil: ProjectFile2.tekst
Endringer ikke iscenesatt for forpliktelse:
(Bruk 'git add/rm ...' for å oppdatere det som blir begått)
(Bruk 'Git Checkout - ...' for å forkaste endringer i arbeidskatalogen)
Slettet: Mary.tekst
Droppet refs/stash@0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

Andre gang du spretter stash, får du 'John.Txt'-relaterte endringer:

$ git stash pop
Fjerner John.tekst
På grenmester
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Ny fil: ProjectFile1.tekst
Ny fil: ProjectFile2.tekst
Endringer ikke iscenesatt for forpliktelse:
(Bruk 'git add/rm ...' for å oppdatere det som blir begått)
(Bruk 'Git Checkout - ...' for å forkaste endringer i arbeidskatalogen)
Slettet: John.tekst
Slettet: Mary.tekst
Droppet refs/stash@0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ ls
ProjectFile1.TXT ProjectFile2.tekst

Og du har din arbeids-i-progress 'ProjectFile1.txt 'og' ProjectFile2.txt 'tilbake.

Så Git Stash -kommandoen hjelper deg med å stash arbeidet ditt, slik at du kan komme tilbake til det senere.

21. git status

GIT -status -kommandoen viser forskjellen mellom gjeldende filer og hodet forpliktelse.

Her er et eksempel:

$ git status
På grenmester
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Omdøpt: File2.txt -> file3.tekst
Endringer ikke iscenesatt for forpliktelse:
(Bruk 'git add ...' for å oppdatere det som blir begått)
(Bruk 'Git Checkout - ...' for å forkaste endringer i arbeidskatalogen)
Endret: Fil1.tekst

Det viser at 'File2.txt 'blir omdøpt til' File3.txt 'som er klar for forpliktelse, men endringene i' File1.txt 'er ikke i iscenesettelsesområdet ennå.

Så vi legger til alt:

$ git add -a

Nå når vi sjekker status:

$ git status
På grenmester
Endringer som skal forpliktet:
(Bruk 'Git Reset Head…' til Unstage)
Endret: Fil1.tekst
Omdøpt: File2.txt -> file3.tekst

Vi ser alle endringene er klare for forpliktelse.

22. git tag

Git -tag -kommandoen hjelper deg med å lage tagger for dine viktige historiske punkter. Det brukes vanligvis til å sette opp versjonsnumre.

Git -tag -kommandoen vil vise deg gjeldende tilgjengelige tagger:

$ git tag
v1.0
v2.0

Du kan tagge med kommandoformatet git -taggen:

$ git tag v3.0

For å se hva som er i taggen, kan du bruke Git Show -kommando:

$ git show v1.0
forpliktelse 61e9e8aa1b98b2a657303e6822b291d2374314b5
Forfatter: Zak H
Dato: Thu 22. november 01:06:42 2018 -0800
Første forpliktelse
Diff -Git A/1.txt b/1.tekst
Ny filmodus 100644
Indeks 0000000… E69DE29

Du kan også tagge ved hjelp av en commit hash og kommandoformat git -taggen:

$ git log --oneline
374efe9 modifisert fil
A621765 Legg til
6d6ed84 sekunders forpliktelse
61e9e8a forplikter seg først
$ git tag v4.0 A621765
$ git show v4.0
Forplikt deg A6217650A2C7B2531ECB9C173BA94BD4B3BA7ABD
Forfatter: Zak H
Dato: Thu 22. november 01:15:55 2018 -0800
Legg til
Diff -Git A/1.txt b/1.tekst
Indeks E69DE29… 587BE6B 100644
--- A/1.tekst
+++ b/1.tekst
@@ -0,0 +1 @@

For å konkludere

For enhver kommando kan du bruke git -h for å få mer info.

Videre studier

• https: // git-cm.com/dokumenter