22 „Essential Git“ komandos

„Git“ tapo esmine versijų valdymo sistema. „Git“ populiarumo augimą galima sieti su jo greičiu, judrumu ir universalumu. Nesvarbu, ar esate laisvai samdomas žiniatinklio kūrėjas, ar įmonės lygio programų programinės įrangos dizaineris, galite naudotis „Git“. Tai padeda jums sekti failus sistemingai kuriant versijas. „Git“ leidžia lengviau grįžti prie senesnių kodo versijų arba sukurti naujų šakų, kad galėtumėte eksperimentuoti su dabartine kodų baze. Be to, „Git“ yra paskirstyta versijų valdymo sistema, o tai reiškia, kad jums nereikia visada prisijungti prie centrinio serverio, kad galėtumėte atlikti savo darbą.Toliau pateikiamos pagrindinės „Git“ komandos, kurios padės atlikti kasdienes užduotis. Paprasti pavyzdžiai suteiks supratimą apie komandas, todėl galėsite lengvai prisiminti sintaksę, kai jums reikės jas naudoti.

1. git pridėti

„Git add“ komanda leidžia pradėti stebėti „Git“ saugyklos failus ir aplankus ir perkelti juos į sustojimo sritį. Turėsite naudoti komandą „git commit“, kad jos būtų nuolatinės jūsų istorinėse nuotraukose.

Komandą lengva naudoti. Galite pasirinkti pridėti failus ir aplankus atskirai arba naudoti „Linux“ tipo žvaigždutės (*) glob operatorių, jei norite juos pridėti grupėse.

Paimkime toliau pateiktą pavyzdį:

Tarkime, kad aukščiau nurodytu atveju mes jau pridėjome „ReadMe“.txt. Bet likę failai nebuvo pridėti.

Patikrinkime būseną:

$ git būsena
Filialo kapitonas
Jūsų filialas atnaujintas su „origin / master“.
Neatsekti failai:
(naudokite 'git add ... “įtraukti į tai, kas bus įsipareigota)
failas1.txt
failas2.txt
aplankas1 /

Failai ir aplankai yra raudonai, o tai reiškia, kad jie nėra stebimi. Mes galime juos pridėti naudodami:

$ git pridėti failą1.txt failas2.txt aplankas1 / *

Jei dabar patikrinsime būseną:

$ git būsena
Filialo kapitonas
Jūsų filialas atnaujintas su „origin / master“.
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
naujas failas: failas1.txt
naujas failas: failas2.txt
naujas failas: aplankas1 / failas3.txt
naujas failas: aplankas1 / failas4.txt

„Git add“ komanda pridėjo failus prie sustojimo srities. Failai laikomi sustojimo srityje, prieš juos padarant nuolatinius vykdymo proceso metu.

2. gito šaka

„Git“ filialas yra lengvas. Kitose versijų valdymo sistemose tai buvo brangi operacija. Bet „Git“ algoritmai yra optimizuoti šakojimui. Taigi galite naudoti „git branch“ komandą, kai tik norite sukurti atskirą kūrimo liniją, nesijaudindami dėl našumo.

Pažvelkime į šį pavyzdį.

Atkreipkite dėmesį, kad esame „filialo kapitonas“. Sukūrę naują projektą pateksite į filialo meistrą. Taip pat galite naudoti komandą „git branch -a“, kad sužinotumėte, kuriame filiale esate:

$ git filialas -a
* meistras

Pirmiau sakoma, kad yra tik viena šaka, vadinama „meistru“, o žvaigždutė (*) reiškia, kad esate toje šakoje.

Sukurkime naują filialą, vadinamą „testavimas“:

$ git filialo testavimas

Dabar mes vėl galime patikrinti šakas:

$ git filialas -a
* meistras
testavimas

Nors mes vis dar esame „pagrindiniame“ filiale, taip pat galime pamatyti naują sukurtą „testavimo“ filialą. „Testavimo“ filialas yra „pagrindinio“ filialo kopija.

3. git kasa

„Git checkout“ komanda nukreipia jus į filialą, todėl galite dirbti su ten esančiais ištekliais. Apie šakas galite galvoti kaip apie upes ir upelius. Su filialu sukuriate naują srautą. Naudodami „Checkout“ komandą, jūs einate į tą srautą.

Patikrinkime ankstesnio pavyzdžio „testavimo“ filialą:

$ git patikros testavimas
Perjungtas į filialo „testavimą“

Dabar dar kartą patikrinkime būseną ir filialus:

$ git būsena
Dėl filialo testavimo
nieko neįsipareigoti, darbo katalogas švarus
$ git filialas -a
meistras
* testavimas

Iš komandos „git branch“ -a galite pamatyti, kad mes persikėlėme į testavimo šaką.

4. git klonas

„Git clone“ komanda leidžia jums padaryti bet kurios „Git“ saugyklos kopiją. Kai tik klonuosite saugyklą, naujas klonuotas aplankas pradės stebėti pokyčius vietoje. Kadangi „Git“ yra platinamas, klonas yra visiškai savarankiška „Git“ saugykla.

Norėdami parodyti, kaip veikia klonavimas, sukurkime naują saugyklą:

$ mkdir dir1
$ cd dir1
$ mkdir myproject
$ cd myproject /
$ git init
Inicijuota tuščia „Git“ saugykla aplanke / dir1 / myproject /.git /
$ palieskite „ReadMe“.txt
$ git įsipareigoti -m 'Inicializuoti mano saugyklą'
[meistras (root-įsipareigoti) 5a0bd75] Inicializuoti mano saugyklą
Pakeistas 1 failas, 0 įterpimų (+), 0 pašalinimų (-)
sukurti režimą 100644 „ReadMe“.txt

Ankstesniame pavyzdyje mes sukūrėme „Git“ saugyklą pavadinimu „myproject“ aplanke „dir1“. Tarkime, tai yra pagrindinė mūsų saugykla. Dabar norime pasidaryti jo kopiją ir dirbti kitur.

Sukurkime katalogą „dir2“ ir klonuokime „myproject“ saugyklą. Mes naudojame git kloną

klonuoti „myproject“:

$ mkdir dir2
$ cd dir2
$ git klonas / dir1 / myproject /
Klonavimas į „myproject“ ..
padaryta.
$ ls
Mano projektas

„Git clone“ komanda taip pat veikia su URL.

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

Taip pat galite pakeisti klono pavadinimą nurodydami jį po „Git“ saugyklos adreso:

$ git klonas https: // github.com / test / test.git mytest

5. git įsipareigoti

Git comm komanda vykdoma po komandos git add. Savo „git add“ pavyzdyje buvome pridėję failus stebėjimui, bet nebuvome jų paskyrę „Git“ saugyklai. Stebėjimas lieka vietinis, kol neįvykdomas įsipareigojimas. Kai atliksite pakeitimus, jie taps nuolatinio įrašo dalimi.

Žemiau mes vykdome git įsipareigoti -m komanda:

$ git įsipareigoti -m 'Mano failų ir aplankų vykdymas'
[master 3ef57b3] Mano failų ir aplankų vykdymas
4 failai pakeisti, 0 įterpimų (+), 0 ištrintų (-)
sukurti režimą 100644 failas.txt
sukurti režimą 100644 failas2.txt
sukurti režimą 100644 aplankas1 / failas3.txt
sukurti režimą 100644 aplankas1 / failas4.txt

Jei nenaudojate parinkties -m komentarui pateikti, „Git“ atidarys numatytąjį teksto redaktorių ir paprašys jo. Komentarai laikomi gera versijų valdymo praktika. Taigi visada darykite reikšmingų komentarų.

6. konfigūracija

Komanda „git config“ leidžia nustatyti įvairias „git“ saugyklos parinktis. Pavyzdžiui, galite naudoti „git config -global“ komandą gauti ir nustatyti savo vartotoją.vardas ir vartotojas.paštu.

Štai kaip galite nustatyti vertes:

$ git config - pasaulinis vartotojas.pavadinimas „Zak H“
$ git config - pasaulinis vartotojas.paštas zakh @ pavyzdys.com

Štai kaip galite patikrinti vertes:

$ git config - pasaulinis vartotojas.vardas
Zak H
$ git config - pasaulinis vartotojas.paštu
zakh @ pavyzdys.com

7. git dif

„Git diff“ komanda padeda pamatyti failų ir aplankų skirtumus. Jei darote pakeitimus faile, tai naudinga priemonė greitai įvertinti atliktus pakeitimus.

Tarkime, kad savo darbą pradėsime naudodami „ReadMe“.txt failas su dviem eilutėmis. Tada mes atsikratome antros eilutės ir pridedame trečią eilutę.

Dabar, jei vykdysime komandą diff, tai parodys skirtumus tarp skirtos versijos ir vietinės pakeistos versijos sustojimo srityje. Štai kaip tai atrodys:

$ git dif
diff --git a / ReadMe.txt b / „ReadMe“.txt
indeksas 9475ddc… 1804904 100644
--- a / „ReadMe“.txt
+++ b / „ReadMe“.txt
@@ -1,2 +1,2 @@
1 eilutė: mano pirmoji eilutė
-2 eilutė: mano antroji eilutė
+3 eilutė: mano TREČIoji eilutė

1 eilutė nepakitusi (balta), 2 eilutė pašalinta (raudona) ir 3 eilutė pridėta (žalia).
Galite naudoti komandą diff taip pat norėdami rasti skirtumų tarp tam tikrų įsipareigojimų.

8. git atnešti

„Git fetch“ komanda gauna naujausius iš nurodytos kilmės šaltinius.

Pažvelkime į pavyzdį. Tarkime, kad turite šią sąlygą:

dir1 / myproject
dir2 / myproject (klonuotas)

Aplankas „dir2 / myproject“ klonuojamas iš „dir1 / myproject“. Dabar, jei kas nors pakeitė „dir1 / myproject“, tokius pakeitimus galite gauti iš „dir2 / myproject“:

$ git gauti kilmę
nuotolinis: objektų skaičiavimas: 2, atlikta.
nuotolinis: objektų suspaudimas: 100% (2/2), atlikta.
nuotolinis: iš viso 2 (delta 0), pakartotinai naudojamas 0 (delta 0)
Išpakuokite daiktus: 100% (2/2), atlikta.
Iš / dir2 /… / dir1 / myproject
5a0bd75… 1713734 meistras -> kilmė / meistras

Svarbu atsiminti, kad „git fetch“ komanda nesujungia pakeitimų. Norėdami automatiškai gauti ir sujungti, naudokite komandą „git pull“. Tada jums gali kilti klausimas, kodėl pirmiausia reikia naudoti šią komandą. Gali būti išplėstinių „Git“ parinkčių, kai visus pakeitimus gaunate iš savo kilmės serverio, o tada pakeitimus taikote tik pasirinktinai tam tikriems failams. „Git fetch“ komanda leidžia tai pasiekti. Tačiau tai yra išplėstinė tema, kurią galite rasti git fetch dokumentuose.

9. git grep

„Git grep“ komanda leidžia ieškoti informacijos „Git“ medyje. Štai pavyzdys ieškant žodžio „Linija“ mūsų „git“ saugykloje. Parinktis -n arba --line-number rodo eilučių numerius, kuriuose „Git“ randa atitikmenį:

$ git grep -n eilutė
Skaityk mane.txt: 1: 1 eilutė: mano pirmoji eilutė
Skaityk mane.txt: 2: 3 eilutė: mano TREČIoji eilutė

Galite atlikti panašią paiešką tiek kartų, kiek yra rungtynių, naudodami parinktį -c arba --count:

git grep -c linija
Skaityk mane.txt: 2

„Git grep“ naudojimo per „Linux grep“ priežastis yra ta, kad „git grep“ yra greitesnis „git“ saugykloms.

10. git žurnalas

„Git log“ komanda rodo įvykdymo istoriją.

$ git žurnalas
įsipareigoti 171373479fc309846ef605fbe650933767afd0fb
Autorius: Zak H
Data: trečiadienis lapkričio 21 d. 20:26:32 2018 -0800
Pridėta naujų failų
įsipareigoti 5a0bd759506d20b2b989873258bf60d003aa3d36
Autorius: Zak H
Data: trečiadienis lapkričio 21 d. 18:48:35 2018 -0800
Inicijuoti mano saugyklą

Norėdami pamatyti sutrumpintą versiją, taip pat galite naudoti parinktį --oneline. Sutrumpintą versiją lengviau sekti.

$ git žurnalas - tiesioginis
1713734 Pridėta naujų failų
5a0bd75 Inicializuoti mano saugyklą

11. susilieti

Git sulieti komanda sujungia šakas.

Sukurkime naują saugyklą su „main“, tada sukursime „test“ filialą.

$ mkdir myproject
$ cd myproject
$ git init
Inicijuota tuščia „Git“ saugykla aplanke / git_essentials / myproject /.git /
$ palieskite „ReadMe“.txt
$ git pridėti -A
$ git įsipareigoti -m 'Pradinis įsipareigojimas'
[pagrindinis (root-įsipareigoti) b31d4e1] Pradinis įsipareigojimas
Pakeistas 1 failas, 0 įterpimų (+), 0 pašalinimų (-)
sukurti režimą 100644 „ReadMe“.txt
$ git filialo testas
$ git filialas -a
* meistras
testas
$ git atsiskaitymo testas
Perjungtas į filialo „testą“

„Test“ skyriuje atlikime keletą pakeitimų:

$ palieskite Failas1.txt File2.txt
USD
Failas1.txt File2.txt „ReadMe“.txt
$ git pridėti -A
$ git įsipareigoti -m 'Pridėjo du naujus failus'
[testas 7e11910] Pridėjo du naujus failus
2 failai pakeisti, 0 įterpimų (+), 0 ištrintų (-)
sukurti režimą 100644 File1.txt
sukurti režimą 100644 File2.txt

Prie testo pridėjome du failus.

$ git filialas -a
meistras
* testas
$ ls
Failas1.txt File2.txt „ReadMe“.txt
$ git atsiskaitymo meistras
Perjungtas į filialo „master“
$ git filialas -a
* meistras
testas
$ ls
Skaityk mane.txt

Iš to, kas išdėstyta pirmiau, matome, kad File1.txt ir File2.txt yra „testo“ šakoje, bet ne „master“.

Susijungsime dabar.

$ git sujungimo testas
Atnaujinamas b31d4e1… 7e11910
Pirmyn
Failas1.txt | 0
Failas2.txt | 0
2 failai pakeisti, 0 įterpimų (+), 0 ištrintų (-)
sukurti režimą 100644 File1.txt
sukurti režimą 100644 File2.txt
$ ls
Failas1.txt File2.txt „ReadMe“.txt
$ git filialas -a
* meistras
testas

Dabar mes turime failą1.txt 'ir' File2.txt 'ir' master 'filiale.

Pastaba: susiliejimą laikykite traukimo operacija. Jūs turite būti filiale, į kurį norite susilieti. Tokiu atveju esate „pagrindiniame“ filiale ir traukiate pakeitimus iš „testo“ šakos.

12. git mv

„Git mv“ yra nuoroda komandai paleisti „git add“ ir „git rm“ komandas. Juo galima pervardyti failus.

Štai pavyzdys:

$ git mv „ReadMe“.txt „ReadMe“.md
$ git būsena
Filialo kapitonas
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
pervadinta: „ReadMe“.txt -> Skaityti.md

13. git traukti

„Git pull“ komanda yra labai panaši į „git“ gavimą, išskyrus tai, kad sujungimas vyksta automatiškai.

Čia yra „git pull“ kilmės, pvz., „Git“, pavyzdys (vykdome klono traukimo užklausą, kad gautume pakeitimus iš pradinės „Git“ saugyklos):

$ git pull kilmė
nuotolinis: objektų skaičiavimas: 3, atlikta.
nuotolinis: objektų suspaudimas: 100% (2/2), atlikta.
nuotolinis: iš viso 3 (delta 0), pakartotinai panaudotas 0 (delta 0)
Išpakuokite objektus: 100% (3/3), atlikta.
Iš / LearnGIT / git_essentials / myproject
7e11910… e67f932 master -> origin / master
Atnaujinamas 7e11910 ... e67f932
Pirmyn
Failas1.txt | 1 +
Failas2.txt | 1 +
Failas3.txt | 1 +
Skaityk mane.txt => Skaityti.md | 0
Pakeisti 4 failai, 3 įterpimai (+)
sukurti režimą 100644 File3.txt
pervardyti „ReadMe“.txt => Skaityti.md (100%)

Galite pamatyti, kad pakeitimai buvo atsisiųsti iš kilmės ir sujungti į kloną.

14. git stumti

„Git push“ komanda naudojama nuotolinių saugyklų pakeitimams perduoti. Štai pavyzdys, kaip paleisti „push“ komandą:

$ git push kilmės meistras
Objektų skaičiavimas: 2, atlikta.
Delta suspaudimas naudojant iki 4 siūlų.
Suspausti objektai: 100% (2/2), padaryta.
Rašyti objektus: 100% (2/2), 242 baitai | 0 baitų / s, atlikta.
Iš viso 2 (1 delta), pakartotinai panaudota 0 (0 delta)
Į / LearnGIT / git_essentials / myproject
e67f932… 90dc546 meistras -> meistras

„Git push“ kilmės pagrindinė komanda siunčia pakeitimus „pagrindiniam“ kilmės šakai („Git“ saugyklai, kurią klonavote) iš klonuotos saugyklos „pagrindinio“ filialo. Vizualiai postūmis atrodo taip:

klonuotas / meistras -> kilmė / meistras

15. git rebase

„Git rebase“ komanda padeda pakeisti šakų pagrindą. Apskritai susijungiant įvyksta kažkas panašaus:

Testavimo šaka sujungta į „pagrindinį“ skyrių, kad būtų sukurtas naujas įsipareigojimas.

Pertvarkant taip atsitinka:

Pokyčiai nuo E ir F keitiklių sąrašo yra perskaičiuojami ir užfiksuojami pagrindinės šakos pabaigoje. Pakartotinis pateikimas padeda supaprastinti šakas.

Tarkime, kad tokia situacija yra „pagrindiniame“ filiale:

$ git žurnalas - tiesioginis
7f573d8 Įsipareigokite C: pridėta c.txt
795da3c Įsipareigokite B: pridėta b.txt
0f4ed5b įsipareigoti A: pridėta a.txt

Ir funkcijų šaka:

$ git žurnalas - tiesioginis
8ed0c4e Įsipareigokite F: pakeista b.txt
6e12b57 Įsipareigokite E: pakeista a.txt
795da3c Įsipareigokite B: pridėta b.txt
0f4ed5b Įsipareigojimas A: pridėta a.txt

Jei perkursime iš naujo, gausime „git“ perkrovos meistrą:

„$ git“ kasos funkcija
Perjungta į filialo „funkciją“
$ git perkrovimo meistras

Pirma, atsukdami galvą, kad galėtumėte pakartoti savo darbą ..

Taikoma: Įsipareigokite E: pakeista a.txt
Taikoma: Įsipareigokite F: pakeista b.txt
Tada sujunkite „funkciją“ į „pagrindinę“.
$ git atsiskaitymo meistras
Perjungtas į filialo „master“
$ git suliejimo funkcija
Atnaujinama 7f573d8… 9efa1a3
Pirmyn
a.txt | 1 +
b.txt | 1 +
2 failai pakeisti, 2 įterpimai (+)

Dabar, jei eisite į „master“ ir „feature“ filialą, pamatysite tuos pačius žurnalus:

$ git žurnalas - tiesioginis
9efa1a3 Įsipareigokite F: pakeista b.txt
8710174 Įsipareigojimas E: modifikuotas a.txt
7f573d8 Įsipareigokite C: pridėta c.txt
795da3c Įsipareigokite B: pridėta b.txt
0f4ed5b įsipareigoti A: pridėta a.txt

„Rebasing“ sutriuškino juos kartu.

Pastaba: niekada nenaudokite pakartotinio pakeitimo viešose saugyklose, nes kūrėjams kils didelių sujungimo problemų.

16. git nuotolinis

„Git“ nuotolinė komanda leidžia jums nustatyti nuotolinį serverio saugyklą. Klonavimo atveju šaltinio saugykla automatiškai tampa nuotoline.

Pavyzdžiui:

$ pwd
/ LearnGIT / git_essentials / test
$ git nuotolinis -v
origin / LearnGIT / git_essentials / myproject (gauti)
origin / LearnGIT / git_essentials / myproject („push“)

Tai rodo, kad nuotolinis serveris, skirtas „testui“, yra kitas aplankas, vadinamas „myproject“. Priežastis ta, kad mano projektui buvo klonuotas „testas“.

Bet nuotolinis serveris nebūtinai turi būti vietinis. Galite turėti kažką panašaus su URL:

$ git nuotolinis -v
kilmė https: // github.com / zakh / myproject (gauti)
kilmė https: // github.com / zakh / myproject („push“)

Galite nustatyti „git“ nuotolinę saugyklą naudodami komandą „git remote add“ :

$ git nuotolinis pridėkite kilmę https: // github.com / zakh / myproject

Tai sujungs jūsų atpirkimo sandorį su kilme, kad galėtumėte gauti ir paspausti.

17. git atstatyti

„Git“ atstatymas leidžia ištrinti pridėtus failus.

Tarkime, kad pridėjote failo testą.txt 'į savo saugyklą:

$ lietimo testas.txt
$ git pridėti -A
$ git būsena
Filialo kapitonas
Jūsų filialas atnaujintas su „origin / master“.
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
naujas failas: testas.txt

Tačiau nusprendžiate, kad nenorite sekti „testo“.txt '. Galite naudoti „git reset head“ komanda ištrinti failą:

$ git reset HEAD testas.txt

Jei patikrinsite būseną, failas vėl nebus stebimas:

$ git būsena
Filialo kapitonas
Jūsų filialas atnaujintas su „origin / master“.
Neatsekti failai:
(naudokite 'git add ... “įtraukti į tai, kas bus įsipareigota)
testas.txt

Failo testas.txt 'nebesekama.

18. git grįžti

Komanda „git revert“ leidžia pakeisti pakeitimus naudojant „hash“ numerį.

$ echo 'Test 1' >> MyFile.txt
$ git pridėti -A
$ git įsipareigoti -m 'Pridėtas pakeitimas 1'
[master 78a8277] Pridėtas 1 pakeitimas
Pakeisti 2 failai, 1 įterpimas (+)
sukurti režimą 100644 „MyFile“.txt
sukurti režimą 100644 testas.txt
$ katė „MyFile“.txt
1 testas
$ echo 'Test 2' >> MyFile.txt
$ git pridėti -A
$ git įsipareigoti -m '2 pridėtas pakeitimas'
[master a976e9c] Pridėtas 2 pakeitimas
1 failas pakeistas, 1 įterpimas (+)
$ katė „MyFile“.txt
1 testas
2 testas
$ git žurnalas - tiesioginis
a976e9c pridėtas 2 pakeitimas
78a8277 Pridėtas 1 pakeitimas
90dc546 Pridėjo failą
e67f932 Pridėta naujų failų
7e11910 Pridėjo du naujus failus
b31d4e1 Pradinis įsipareigojimas

Mes sukūrėme „MyFile“.txt “ir atliko du pakeitimus, todėl faile yra eilutės„ Test 1 “ir„ Test 2 “. Bet mes nusprendėme, kad nenorime antro įsipareigojimo. Taigi radome jam skirtą maišos kodą (a976e9c). Mes galime naudoti „Git Revert“ atsikratyti įsipareigojimo:

$ git revert a976e9c
[master 4f270e7] Grąžinti „Pridėtas pakeitimas 2“
1 failas pakeistas, 1 ištrintas (-)
$ git žurnalas - tiesioginis
4f270e7 Grąžinti „Pridėtą 2 pakeitimą“
a976e9c pridėtas 2 pakeitimas
78a8277 Pridėtas 1 pakeitimas
90dc546 Pridėjo failą
e67f932 Pridėta naujų failų
7e11910 Pridėjo du naujus failus
b31d4e1 Pradinis įsipareigojimas
$ katė „MyFile“.txt
1 testas

Matome, kad buvo sukurtas naujas įvykdymo maišas, kuris panaikino „Test 2“ eilutės įsipareigojimą. Dabar faile yra tik eilutė „Test 1“.

19. git rm

„Git rm“ komanda nustato failus būsimiems trynimams. Tai iškelia failus, kuriuos reikia ištrinti sustojimo srityje.

$ git rm testas.txt
rm 'testas.txt '
$ git būsena
Filialo kapitonas
Jūsų filialas 3 įsipareigojimais lenkia „origin / master“.
(vietiniams įsipareigojimams paskelbti naudokite „git push“)
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
ištrinta: testas.txt

Kad ištrynimas įsigaliotų, turite atlikti pakeitimus.

20. git paslėpti

„Git stash“ komanda leidžia laikinai atsisakyti darbų, kurių dar nesate pasirengę atlikti.
Tarkime, kad dirbate saugykloje su šiais failais:

$ ls
Jonas.txt Marija.txt
Norite pakeisti šiuos failus labiau pagrįstais projektais. Taigi jūs pradedate nuo:
$ git mv Jonas.txt ProjectFile1.txt
$ ls
Marija.txt ProjectFile1.txt
$ git būsena
Filialo kapitonas
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
pervadinta: Jonas.txt -> ProjectFile1.txt

Viduryje pervadinti ir atnaujinti „John.txt 'į' ProjectFile1.txt ', jūs gaunate prašymą ką nors pakeisti projekte. Bet jūs nesate pasirengę pateikti „ProjectFile1“.txt '. Taigi jūs jį paslėpėte.

$ git paslėpti

Išsaugotas pagrindinio darbo katalogo ir indekso būsenos WIP: f0b5a01 Init Jonas ir Marija

HEAD dabar yra f0b5a01 Init Jonas ir Marija

$ ls
Jonas.txt Marija.txt

Jūsų vietinė darbo aplinka grįžo ten, kur buvote prieš atlikdami projektinius pakeitimus. Pasirūpinęs pertraukimu, užuot grįžęs pas Joną.txt “, jūs nusprendėte dirbti su„ Marija.txt 'failas dabar:

$ git mv Marija.txt ProjectFile2.txt
$ git būsena
Filialo kapitonas
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
pervadinta: Marija.txt -> ProjectFile2.txt
$ ls
Jonas.txt ProjectFile2.txt

Jūs vėl pertraukiate ir paslepiate savo naują kūrinį „Marija.txt ':

$ git paslėpti
Išsaugotas pagrindinio darbo katalogo ir indekso būsenos WIP: f0b5a01 Init Jonas ir Marija
HEAD dabar yra f0b5a01 Init Jonas ir Marija
$ ls
Jonas.txt Marija.txt

Atlikę pertraukimo darbus, patikrinsite saugyklų sąrašą:

„$ git“ paslėpimo sąrašas
atlicināt @ 0: WIP meistrui: f0b5a01 Init Jonas ir Marija
paslėpti @ 1: NUOŠKITE meistrą: f0b5a01 Initas Jonas ir Marija

Jūs turite dvi nebaigtas prekes (WIP). Pirmą kartą paleidus atlicynę, gausite naujausią „Mariją“.txt 'pakeitimai:

$ git paslėpimo pop
Marijos pašalinimas.txt
Filialo kapitonas
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
naujas failas: ProjectFile2.txt
Pakeitimai, kurie nebuvo surengti įvykdyti:
(naudokite 'git add / rm ... "atnaujinti, kas bus įsipareigota)
(naudokite „git checkout“ -- … “, Norėdami atmesti darbo katalogo pakeitimus)
išbraukta: Marija.txt
Nukrito nuorodos / atlicināt @ 0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

Antrą kartą užklupus atlicynę, gausite „John.su txt susiję pakeitimai:

$ git paslėpimo pop
Jono pašalinimas.txt
Filialo kapitonas
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
naujas failas: ProjectFile1.txt
naujas failas: ProjectFile2.txt
Pakeitimai, kurie nebuvo surengti įvykdyti:
(naudokite 'git add / rm ... "atnaujinti, kas bus įsipareigota)
(naudokite „git checkout“ -- … “, Norėdami atmesti darbo katalogo pakeitimus)
išbraukta: Jonas.txt
išbraukta: Marija.txt
Nukrito nuorodos / atlicināt @ 0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ ls
„ProjectFile“.txt ProjectFile2.txt

Ir jūs turite savo nebaigtą darbą „ProjectFile1“.txt “ir„ ProjectFile2 “.txt 'atgal.

Taigi „git stash“ komanda padeda jums išsaugoti savo darbą, kad galėtumėte prie jo grįžti vėliau.

21. git statusas

Komanda „git status“ rodo skirtumą tarp esamų failų ir „HEAD“ įsipareigojimų.

Štai pavyzdys:

$ git būsena
Filialo kapitonas
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
pervadinta: File2.txt -> File3.txt
Pakeitimai, kurie nebuvo surengti įvykdyti:
(naudokite 'git add ... "atnaujinti, kas bus įsipareigota)
(naudokite „git checkout“ -- … “, Norėdami atmesti darbo katalogo pakeitimus)
modifikuota: File1.txt

Tai rodo, kad „File2.txt “pervadinamas į„ File3 “.„txt“, kuris yra paruoštas įsipareigojimui, tačiau modifikacijos faile „File1“.txt 'dar nėra sustojimo vietoje.

Taigi, mes pridėjome viską:

$ git pridėti -A

Dabar, kai tikriname būseną:

$ git būsena
Filialo kapitonas
Pakeitimai, kuriuos reikia atlikti:
(naudokite 'git reset HEAD ... “iki scenos)
modifikuota: File1.txt
pervadinta: File2.txt -> File3.txt

Matome, kad visi pakeitimai yra pasirengę įvykdyti.

22. „git“ žyma

„Git tag“ komanda padeda sukurti žymes svarbiems istoriniams taškams. Paprastai jis naudojamas versijų numeriams nustatyti.

„Git tag“ komanda parodys dabartines galimas žymas:

$ git žyma
v1.0
v2.0

Galite pažymėti komandos formato „git“ žyma :

$ git tag v3.0

Norėdami pamatyti, kas yra žymoje, galite naudoti komandą „git show“:

$ git šou v1.0
įsipareigoti 61e9e8aa1b98b2a657303e6822b291d2374314b5
Autorius: Zak H
Data: antradienis, lapkričio 22 d., 01:06:42, 2018 -0800
Pirmiausia įsipareigokite
diff --git a / 1.txt b / 1.txt
naujas failo režimas 100644
indeksas 0000000… e69de29

Taip pat galite žymėti naudodami „hash“ ir komandos formato „git“ žymą :

$ git žurnalas - tiesioginis
374efe9 Pakeistas failas
a621765 Pridėti
6d6ed84 Antras įsipareigojimas
61e9e8a Pirmiausia įsipareigokite
$ git tag v4.0 a621765
$ 4 git v4.0
įsipareigoti a6217650a2c7b2531ecb9c173ba94bd4b3ba7abd
Autorius: Zak H
Data: antradienis, lapkričio 22 d., 01:15:55, 2018 -0800
Papildyti
diff --git a / 1.txt b / 1.txt
indeksas e69de29… 587be6b 100644
--- a / 1.txt
+++ b / 1.txt
@@ -0,0 +1 @@

Apibendrinant

Bet kuriai komandai galite naudoti „git“ -h gauti daugiau informacijos.

Tolesnis tyrimas

https: // git-scm.com / docs