22 viktige Git-kommandoer

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

1. git add

Med kommandoen git add kan du begynne å spore filer og mapper for Git-arkivet og flytte dem til iscenesettingsområdet. Du må bruke kommandoen git commit for å gjøre dem permanente på dine historiske øyeblikksbilder.

Det er enkelt å bruke kommandoen. Du kan velge å legge til filer og mapper enkeltvis eller bruke Linux-stjerne (*) globoperatør for å legge dem til i grupper.

La oss ta eksemplet nedenfor:

Anta at i ovennevnte tilfelle har vi allerede 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 'opprinnelse / mester'.
Usporede filer:
(bruk 'git add ... 'å inkludere i det som blir forpliktet)
fil1.tekst
fil2.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 fil 1.txt-fil 2.txt mappe1 / *

Hvis vi sjekker statusen nå:

$ git-status
På grenmester
Filialen din er oppdatert med 'opprinnelse / mester'.
Endringer som skal begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
ny fil: file1.tekst
ny fil: file2.tekst
ny fil: mappe1 / fil3.tekst
ny fil: mappe1 / fil4.tekst

Kommandoen git add har lagt til filene i iscenesettingsområdet. Filer oppbevares i iscenesettelsesområdet før de blir permanente gjennom kommisjonsprosessen.

2. git gren

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

La oss se på følgende eksempel.

Legg merke til at vi er 'On branch master'. Når du oppretter et nytt prosjekt, havner du i filialmester. Du kan også bruke kommandoen git branch -a for å finne ut hvilken gren du er på:

$ git gren -a
* mester

Ovennevnte forteller deg at det bare er en gren kalt 'master', og stjernen (*) betyr at du er på den grenen.

La oss lage en ny gren kalt 'testing':

$ git gren testing

Nå kan vi sjekke grenene igjen:

$ git gren -a
* mester
testing

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

3. git kassa

Kommandoen git checkout 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 kassen kommandoen, flytter du til den strømmen.

La oss sjekke ut 'test' -grenen fra forrige eksempel:

$ git checkout testing
Byttet til gren 'testing'

La oss nå sjekke statusen og grenene igjen:

$ git-status
På grenprøving
ingenting å begå, arbeider katalogen ren
$ git gren -a
herre
* testing

Du kan se fra git branch -a-kommandoen at vi har flyttet til testgrenen.

4. git klon

Git clone-kommandoen lar deg lage en kopi av et hvilket som helst Git-arkiv. Så snart du kloner et depot, begynner den nye klonede mappen å holde rede på endringer lokalt. Fordi Git distribueres, er en klon et fullstendig autonomt Git-depot.

For å vise hvordan kloning fungerer, la oss opprette et nytt arkiv:

$ mkdir dir1
$ cd dir1
$ mkdir mitt prosjekt
$ cd myproject /
$ git init
Initialisert tomt Git-depot i / dir1 / myproject /.git /
$ touch ReadMe.tekst
$ git commit -m 'Initialize my repository'
[master (root-commit) 5a0bd75] Initialiser depotet mitt
1 fil endret, 0 innsettinger (+), 0 slettinger (-)
opprett modus 100644 ReadMe.tekst

I eksemplet ovenfor har vi opprettet Git-depot kalt 'myproject' i 'dir1' -mappen. Anta at dette er vårt hovedlager. Nå vil vi lage en kopi av den og jobbe andre steder.

La oss lage en katalog kalt 'dir2' og klone 'myproject' -registeret. Vi bruker git-klonen

å klone 'myproject':

$ mkdir dir2
$ cd dir2
$ git clone / dir1 / myproject /
Kloning til 'mittprosjekt' ..
ferdig.
$ ls
mitt prosjekt

Kommandoen git clone 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 begå

Kommandoen git commit kjøres etter kommandoen git add. I vårt eksempel på git add hadde vi lagt til filene for sporing, men vi hadde ikke forpliktet det til Git-depotet. Sporing forblir lokal til en forpliktelse er gjort. Når du foretar endringene, blir de en del av den faste posten.

Nedenfor kjører vi git commit -m kommando:

$ git commit -m 'Forplikte filer og mapper'
[master 3ef57b3] Forplikter filene og mappene mine
4 filer endret, 0 innsettinger (+), 0 slettinger (-)
opprett modus 100644 fil1.tekst
opprett modus 100644 fil2.tekst
opprett modus 100644 mappe1 / fil3.tekst
opprett modus 100644 mappe1 / file4.tekst

Hvis du ikke bruker -m-alternativet for å legge inn en kommentar, åpner Git standard tekstredigerer og ber om det. Kommentarer betraktes som god praksis for versjonskontroll. Så legg alltid meningsfulle kommentarer til forpliktelsen.

6. git config

Med kommandoen git config kan du konfigurere forskjellige alternativer for git-arkivet. For eksempel kan du bruke git config -global kommando for å hente og stille brukeren din.navn og bruker.e-post.

Slik kan du sette verdiene:

$ git config - global bruker.navn 'Zak H'
$ git config - global bruker.e-post zakh @ eksempel.com

Slik kan du sjekke verdiene:

$ git config - global bruker.Navn
Zak H
$ git config - global bruker.e-post
zakh @ eksempel.com

7. git diff

Kommandoen git diff 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å kvitter vi oss med den andre linjen og legger til en tredje linje.

Nå hvis vi kjører diff-kommandoen, vil den vise forskjellene mellom den forpliktede versjonen og den lokale endrede versjonen i iscenesettingsområdet. Slik ser det 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 for å også finne forskjeller mellom bestemte forpliktelser.

8. git-henting

Kommandoen git fetch får de nyeste ressursene fra den angitte opprinnelsen.

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

dir1 / myproject
dir2 / myproject (klonet)

Mappen 'dir2 / myproject' er klonet fra 'dir1 / myproject'. Nå hvis noen forpliktet seg til 'dir1 / myproject', kan du få disse endringene slik fra innsiden av 'dir2 / myproject':

$ git hent opprinnelse
fjernkontroll: Telle objekter: 2, ferdig.
fjernkontroll: Komprimeringsobjekter: 100% (2/2), ferdig.
fjernkontroll: Totalt 2 (delta 0), gjenbrukt 0 (delta 0)
Pakke ut gjenstander: 100% (2/2), ferdig.
Fra / dir2 /… / dir1 / myproject
5a0bd75… 1713734 master -> origin / master

Det er viktig å huske at git fetch-kommandoen ikke slår sammen endringene. Bruk git pull-kommandoen for automatisk henting og sammenslåing. Da lurer du kanskje på hvorfor du bruker denne kommandoen i utgangspunktet. Det kan være avanserte Git-alternativer der du får alle endringene fra opprinnelsesserveren din og deretter bare bruker endringer selektivt på bestemte filer. Kommandoen git fetch lar deg oppnå dette. Det er imidlertid et avansert emne som du finner i dokumentasjonen for git-henting.

9. git grep

Git grep-kommandoen lar deg søke i Git-treet ditt for informasjon. Her er et eksempel på å søke på ordet 'Line' i vårt git-arkiv. Alternativet -n eller --line-number viser linjenumre der Git finner en kamp:

$ git grep -n Line
Les meg.txt: 1: Linje 1: Min første linje
Les meg.txt: 2: Linje 3: Min TREDJE linje

Du kan kjøre et lignende søk for antall ganger kampen er der med -c eller --count alternativ:

git grep -c Line
Les meg.tekst: 2

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

10. git logg

Kommandoen git log viser deg forpliktelseshistorikken.

$ git-logg
begå 171373479fc309846ef605fbe650933767afd0fb
Forfatter: Zak H
Dato: ons 21 nov 20:26:32 2018 -0800
Nye filer lagt til
begå 5a0bd759506d20b2b989873258bf60d003aa3d36
Forfatter: Zak H
Dato: Ons 21. nov 18:48:35 2018 -0800
Initialiser depotet mitt

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

$ git log --online
1713734 Nye filer lagt til
5a0bd75 Initialiser depotet mitt

11. git flette

Kommandoen git merge fletter sammen grener.

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

$ mkdir mitt prosjekt
$ cd myproject
$ git init
Initialisert tomt Git-arkiv i / git_essentials / myproject /.git /
$ touch ReadMe.tekst
$ git add -A
$ git commit -m 'Initial commit'
[master (root-commit) b31d4e1] Initial commit
1 fil endret, 0 innsettinger (+), 0 slettinger (-)
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 testgrenen:

$ trykk på File1.txt File2.tekst
$ Ls
Fil 1.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å testen.

$ git gren -a
herre
* test
$ ls
Fil 1.txt File2.txt ReadMe.tekst
$ git checkout master
Byttet til gren 'master'
$ git gren -a
* mester
test
$ ls
Les meg.tekst

Vi ser fra ovenstående at File1.txt og File2.txt eksisterer i 'test' gren, men ikke i 'master'.

La oss slå oss sammen nå.

$ git merge test
Oppdaterer b31d4e1 ... 7e11910
Spol fremover
Fil 1.txt | 0
Fil2.txt | 0
2 filer endret, 0 innsettinger (+), 0 slettinger (-)
opprett modus 100644 File1.tekst
opprett modus 100644 File2.tekst
$ ls
Fil 1.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å sammenslåing som en trekkoperasjon. Du må være i grenen du vil smelte inn i. I dette tilfellet er du i "master" -grenen og trekker endringene fra "test" -grenen.

12. git mv

Git mv er en hurtigtastkommando for å kjøre git add- og git rm-kommandoer. Den 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 begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
omdøpt: ReadMe.txt -> ReadMe.md

1. 3. git pull

Git pull-kommandoen er mye som git-hentingen, bortsett fra at flettingen skjer automatisk.

Her er et eksempel på å kjøre git pull-opprinnelse som git-hente en (vi kjører en pull-forespørsel fra klonen for å få endringer fra det opprinnelige Git-depotet):

$ git pull opprinnelse
fjernkontroll: Telle objekter: 3, ferdig.
fjernkontroll: Komprimeringsobjekter: 100% (2/2), ferdig.
fjernkontroll: Totalt 3 (delta 0), gjenbrukt 0 (delta 0)
Utpakking av gjenstander: 100% (3/3), ferdig.
Fra / LearnGIT / git_essentials / myproject
7e11910 ... e67f932 master -> opprinnelse / master
Oppdaterer 7e11910 ... e67f932
Spol fremover
Fil 1.txt | 1 +
Fil2.txt | 1 +
File3.txt | 1 +
Les meg.txt => Les meg.md | 0
4 filer endret, 3 innsettinger (+)
opprett modus 100644 File3.tekst
endre navn på ReadMe.txt => Les meg.md (100%)

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

14. git push

Kommandoen git push brukes til å skyve endringer i eksterne arkiver. Her er et eksempel på å kjøre push-kommandoen:

$ git push origin master
Telleobjekter: 2, ferdig.
Delta komprimering med opptil 4 tråder.
Komprimeringsobjekter: 100% (2/2), ferdig.
Skriveobjekter: 100% (2/2), 242 byte | 0 byte / s, ferdig.
Totalt 2 (delta 1), gjenbrukt 0 (delta 0)
Til / LearnGIT / git_essentials / myproject
e67f932… 90dc546 master -> master

Master kommandoen git push origin sender endringer til "master" -grenen til opprinnelsen (Git-depotet du klonet) fra "master" -grenen til det klonede depotet. Visuelt ser push ut slik:

klonet / master -> opprinnelse / master

15. git rebase

Kommandoen git rebase hjelper deg med å endre basen til grenene. I en generell sammenslåing skjer noe slikt:

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

I en rebase er dette hva som skjer:

Endringene fra E- og F-endringsliste beregnes på nytt og låses på slutten av mastergrenen. Rebasing hjelper til med å forenkle grenene.

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

$ git log --online
7f573d8 Forplikt C: lagt til c.tekst
795da3c Forpliktelse B: lagt til b.tekst
0f4ed5b Forpliktelse A: lagt til a.tekst

Og en funksjonsgren:

$ git log --online
8ed0c4e Forplikt F: modifisert b.tekst
6e12b57 Commit E: modifisert a.tekst
795da3c Forpliktelse B: lagt til b.tekst
0f4ed5b Forplikt A: lagt til a.tekst

Hvis vi rebase, får vi git rebase master:

$ git utsjekkingsfunksjon
Byttet til filialfunksjon
$ git rebase master

Først spoler du hodet tilbake for å spille arbeidet ditt på toppen av det ..

Søker: Forplikt E: endret a.tekst
Søker: Forplikt F: modifisert b.tekst
Slå deretter sammen 'funksjon' til 'master'.
$ git checkout master
Byttet til gren 'master'
$ git merge-funksjon
Oppdaterer 7f573d8… 9efa1a3
Spol fremover
en.txt | 1 +
b.txt | 1 +
2 filer endret, 2 innsettinger (+)

Nå hvis du går til både 'master' og 'feature' -grenen, ser du de samme loggene:

$ git log --online
9efa1a3 Forpliktelse F: modifisert b.tekst
8710174 Forplikte E: endret a.tekst
7f573d8 Forplikt C: lagt til c.tekst
795da3c Forpliktelse B: lagt til b.tekst
0f4ed5b Forpliktelse A: lagt til a.tekst

Rebasing har knust dem sammen.

Merk: Bruk aldri ombygging i offentlige repositorier, da utviklere vil støte på store problemer med sammenslåing.

16. git fjernkontroll

Med kommandoen git remote kan du angi en ekstern server for depotet ditt. I en kloningsituasjon blir kildedepotet automatisk fjernkontrollen.

For eksempel:

$ pwd
/ LearnGIT / git_essentials / test
$ git fjernkontroll -v
origin / LearnGIT / git_essentials / myproject (fetch)
opprinnelse / 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 fjernkontroll -v
opprinnelse https: // github.com / zakh / myproject (fetch)
opprinnelse https: // github.com / zakh / myproject (push)

Du kan sette opp et git eksternt lager ved å bruke kommandoen git remote add :

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

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

17. git reset

Git-tilbakestillingen lar deg fjerne scenene som legges til.

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 'opprinnelse / mester'.
Endringer som skal begås:
(bruk 'git reset HEAD … 'For å avvikle scenen)
ny fil: test.tekst

Du bestemmer deg imidlertid for at du ikke vil spore testen.txt 'lenger. Du kan bruke git reset Head kommando for å avinstallere filen:

$ git tilbakestill HEAD-test.tekst

Hvis du sjekker statusen, spores filen igjen:

$ git-status
På grenmester
Filialen din er oppdatert med 'opprinnelse / mester'.
Usporede filer:
(bruk 'git add ... 'å inkludere i det som blir forpliktet)
test.tekst

Filens test.txt 'spores ikke lenger.

18. git gå tilbake

Kommandoen git revert lar deg reversere endringer ved hjelp av kommisjonens hash-nummer.

$ echo '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
$ echo '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 --online
a976e9c Lagt til Endring 2
78a8277 Lagt til Endring 1
90dc546 Lagt til en fil
e67f932 Lagt til nye filer
7e11910 Lagt til to nye filer
b31d4e1 Opprinnelig forpliktelse

Vi opprettet en 'MyFile.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-tilbakestillingen å kvitte seg med forpliktelsen:

$ git revert a976e9c
[master 4f270e7] Tilbakestill 'Lagt til endring 2'
1 fil endret, 1 sletting (-)
$ git log --online
4f270e7 Tilbakestill 'Lagt til Endring 2'
a976e9c Lagt til Endring 2
78a8277 Lagt til Endring 1
90dc546 Lagt til en fil
e67f932 Lagt til nye filer
7e11910 Lagt til to nye filer
b31d4e1 Opprinnelig forpliktelse
$ katt MyFile.tekst
Test 1

Vi ser at det ble opprettet en ny kommisjon-hash som tilbakeviste 'Test 2' -linjekommisjonen. Filen har bare 'Test 1' -linjen nå.

19. git rm

Kommandoen git rm setter opp filer for fremtidige slettinger. Det setter filene som skal slettes i iscenesettelsesområdet.

$ git rm test.tekst
rm-test.tekst'
$ git-status
På grenmester
Grenen din er foran "opprinnelse / mester" med tre forpliktelser.
(bruk 'git push' for å publisere lokale forpliktelser)
Endringer som skal begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
slettet: test.tekst

Du må forplikte endringene for at slettingen skal tre i kraft.

20. git stash

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

$ ls
John.tekst Mary.tekst
Du vil endre disse filene for å være mer prosjektbaserte. Så du begynner med:
$ git mv John.txt ProjectFile1.tekst
$ ls
Mary.txt ProjectFile1.tekst
$ git-status
På grenmester
Endringer som skal begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
omdøpt: John.txt -> ProjectFile1.tekst

Midt i å gi nytt navn og oppdatere 'John.txt 'til' ProjectFile1.txt ', får du 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 indeksstatus WIP på master: f0b5a01 Init John og Mary

HEAD er nå på f0b5a01 Init John og Mary

$ ls
John.tekst Mary.tekst

Ditt lokale arbeidsmiljø er tilbake til det du var før du gjorde de prosjektbaserte endringene. Etter å ha fulgt avbruddet, i stedet for å gå tilbake til 'John.txt ', bestemmer du deg for å jobbe med' Mary.txt 'fil nå:

$ git mv Mary.txt ProjectFile2.tekst
$ git-status
På grenmester
Endringer som skal begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
omdøpt: Mary.txt -> ProjectFile2.tekst
$ ls
John.txt ProjectFile2.tekst

Du blir avbrutt igjen, og du stash ditt nye arbeid på 'Mary.tekst':

$ git stash
Lagret arbeidskatalog og indeksstatus WIP på master: f0b5a01 Init John og Mary
HEAD er nå på f0b5a01 Init John og Mary
$ ls
John.tekst Mary.tekst

Etter at avbruddsarbeidet er gjort, sjekker du stashlisten:

$ git stash-liste
stash @ 0: WIP på master: f0b5a01 Init John og Mary
stash @ 1: WIP på master: f0b5a01 Init John og Mary

Du har to pågående arbeid (WIP) i stashen. Første gang du stikker inn, får du det siste 'Mary.txt 'endringer:

$ git stash pop
Fjerner Mary.tekst
På grenmester
Endringer som skal begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
ny fil: ProjectFile2.tekst
Endringer ikke iscenesatt for forpliktelse:
(bruk 'git add / rm ... 'for å oppdatere hva som blir forpliktet)
(bruk 'git checkout -- ... 'for å forkaste endringer i arbeidskatalogen)
slettet: Mary.tekst
Dropp ref / stash @ 0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

Andre gang du setter inn stashen, får du John.txt'-relaterte endringer:

$ git stash pop
Fjerner John.tekst
På grenmester
Endringer som skal begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
ny fil: ProjectFile1.tekst
ny fil: ProjectFile2.tekst
Endringer ikke iscenesatt for begå
(bruk 'git add / rm ... 'for å oppdatere hva som blir forpliktet)
(bruk 'git checkout -- ... 'for å forkaste endringer i arbeidskatalogen)
slettet: John.tekst
slettet: Mary.tekst
Droppet ref / stash @ 0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ ls
ProjectFile1.txt ProjectFile2.tekst

Og du har ditt pågående 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

Kommandoen git status viser forskjellen mellom nåværende filer og HEAD-kommisjonen.

Her er et eksempel:

$ git-status
På grenmester
Endringer som skal begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
omdøpt: File2.txt -> File3.tekst
Endringer ikke iscenesatt for forpliktelse:
(bruk 'git add ... 'for å oppdatere hva som blir forpliktet)
(bruk 'git checkout -- ... 'for å forkaste endringer i arbeidskatalogen)
endret: File1.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 begås:
(bruk 'git reset HEAD ... 'for å avvikle scenen)
endret: File1.tekst
omdøpt: File2.txt -> File3.tekst

Vi ser at alle endringene er klare for forpliktelse.

22. git tag

Kommandoen git tag hjelper deg med å lage koder for viktige historiske punkter. Det brukes vanligvis til å sette opp versjonsnumre.

Kommandoen git tag viser deg de nåværende tilgjengelige kodene:

$ git tag
v1.0
v2.0

Du kan tagge med kommandoformatet git tag :

$ git tag v3.0

For å se hva som er i koden, kan du bruke git show-kommandoen:

$ git show v1.0
begå 61e9e8aa1b98b2a657303e6822b291d2374314b5
Forfatter: Zak H
Dato: Thu 22 Nov 01:06:42 2018 -0800
Begynn først
diff --git a / 1.txt b / 1.tekst
ny filmodus 100644
indeks 0000000… e69de29

Du kan også tagge ved hjelp av en committe-hash og kommandoformatet git-tag :

$ git log --online
374efe9 Endret fil
a621765 Legg til
6d6ed84 Second commit
61e9e8a Første forpliktelse
$ git tag v4.0 a621765
$ git show v4.0
begå a6217650a2c7b2531ecb9c173ba94bd4b3ba7abd
Forfatter: Zak H
Dato: Thu 22 Nov 01:15:55 2018 -0800
Legge 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-scm.com / docs