22 základních příkazů Git

Git se stal zásadním systémem řízení verzí. Vzestup popularity Gitu lze přičíst jeho rychlosti, hbitosti a všestrannosti. Ať už jste nezávislý webový vývojář nebo softwarový designér pro aplikace na podnikové úrovni, můžete těžit z používání Gitu. Pomáhá vám sledovat soubory prostřednictvím systematické správy verzí. Git usnadňuje návrat ke starším verzím kódu nebo vytváření nových větví k experimentování na aktuální kódové základně. Git je také systém řízení distribuované verze, což znamená, že se nemusíte vždy připojovat k centrálnímu serveru, abyste mohli svou práci dokončit.Níže jsou uvedeny základní příkazy Git, které vám pomohou při každodenních úkolech. Jednoduché příklady vám pomohou porozumět příkazům, abyste si mohli snadno zapamatovat syntaxi, když je potřebujete použít.

1. git přidat

Příkaz git add vám umožní začít sledovat soubory a složky pro vaše úložiště Git a přesunout je do pracovní oblasti. Budete muset použít příkaz git commit, aby byly trvalé na vašich historických snímcích.

Použití příkazu je snadné. Můžete se rozhodnout přidat soubory a složky jednotlivě nebo je přidat do skupin pomocí operátoru globálního typu hvězdička (*).

Vezměme si příklad níže:

Předpokládejme, že ve výše uvedeném případě jsme již přidali ReadMe.txt. Ale zbytek souborů nebyl přidán.

Zkontrolujme stav:

stav $ git
Na pobočce
Vaše pobočka je aktuální s „origin / master“.
Nesledované soubory:
(použijte 'git add … “Zahrnout do toho, co bude spácháno)
soubor1.txt
file2.txt
složka1 /

Soubory a složky jsou červené, což znamená, že nejsou sledovány. Můžeme je přidat pomocí:

$ git přidat soubor1.soubor txt2.složka txt1 / *

Pokud nyní zkontrolujeme stav:

stav $ git
Na pobočce
Vaše pobočka je aktuální s „origin / master“.
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
nový soubor: soubor1.txt
nový soubor: file2.txt
nový soubor: složka1 / soubor3.txt
nový soubor: složka1 / soubor4.txt

Příkaz git add přidal soubory do pracovní oblasti. Soubory jsou uchovávány v pracovní oblasti, než jsou během procesu odevzdání trvalé.

2. git větev

Na Gitu je větvení snadné. V jiných systémech pro správu verzí to byla drahá operace. Algoritmy Git jsou ale optimalizovány pro větvení. Příkaz git branch tedy můžete použít, kdykoli chcete vytvořit samostatnou vývojovou linii bez obav o výkon.

Podívejme se na následující příklad.

Všimněte si, že jsme „na pobočce master“. Když vytvoříte nový projekt, skončíte v hlavní větvi. Příkaz git branch -a můžete také zjistit, na které pobočce se nacházíte:

$ git větev -a
* mistr

Výše uvedené vám říká, že existuje pouze jedna větev s názvem „master“ a hvězdička (*) znamená, že jste v této větvi.

Vytvořme novou větev nazvanou 'testování':

$ git testování poboček

Nyní můžeme znovu zkontrolovat větve:

$ git větev -a
* mistr
testování

I když jsme stále na „hlavní“ větvi, můžeme také vidět novou „testovací“ větev, která byla vytvořena. Větev „testování“ je replikou větve „hlavní“.

3. pokladna git

Příkaz git checkout vás zavede do pobočky, takže můžete pracovat na tamních zdrojích. Můžete si představit větve jako řeky a potoky. S pobočkou vytvoříte nový stream. Pomocí příkazu pokladna se přesunete do tohoto streamu.

Pojďme se podívat na větev „testování“ z předchozího příkladu:

$ git checkout testování
Přepnuto na větev „testování“

Nyní zkontrolujeme stav a větve znovu:

stav $ git
Na testování poboček
nic k spáchání, pracovní adresář čistý
$ git větev -a
mistr
* testování

Z příkazu git branch -a můžete vidět, že jsme se přesunuli do testovací větve.

4. git klon

Příkaz git clone umožňuje vytvořit kopii libovolného úložiště Git. Jakmile klonujete úložiště, nová klonovaná složka začne místně sledovat změny. Protože je Git distribuován, klon je plně autonomní úložiště Git.

Abychom ukázali, jak klonování funguje, vytvořme si nové úložiště:

$ mkdir dir1
$ cd dir1
$ mkdir můj projekt
$ cd myproject /
$ git init
Inicializované prázdné úložiště Git v / dir1 / myproject /.git /
$ touch ReadMe.txt
$ git commit -m 'Inicializovat mé úložiště'
[master (root-commit) 5a0bd75] Inicializovat mé úložiště
1 soubor změněn, 0 vložení (+), 0 odstranění (-)
vytvořit režim 100644 ReadMe.txt

Ve výše uvedeném příkladu jsme vytvořili úložiště Git s názvem 'myproject' ve složce 'dir1'. Předpokládejme, že toto je naše hlavní úložiště. Nyní si chceme vytvořit jeho kopii a pracovat jinde.

Vytvořme adresář s názvem 'dir2' a naklonujte úložiště 'myproject'. Používáme klon git

klonovat 'myproject':

$ mkdir dir2
$ cd dir2
$ git clone / dir1 / myproject /
Klonování do „mého projektu“…
Hotovo.
$ ls
můj projekt

Příkaz git clone funguje také s adresou URL.

$ git clone https: // github.com / test / test.sakra

Název klonu můžete také změnit zadáním za adresou úložiště Git:

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

5. git commit

Příkaz git commit se spustí po příkazu git add. V našem příkladu git add jsme přidali soubory pro sledování, ale nezavázali jsme to do úložiště Git. Sledování zůstane lokální, dokud se neprovede potvrzení. Když změny potvrdíte, stanou se součástí trvalého záznamu.

Níže spustíme git commit -m příkaz:

$ git commit -m 'Potvrzování mých souborů a složek'
[master 3ef57b3] Potvrzování mých souborů a složek
4 soubory změněny, 0 vložení (+), 0 odstranění (-)
vytvořit režim 100644 file1.txt
vytvořit režim 100644 file2.txt
režim vytvoření 100644 adresář1 / soubor3.txt
režim vytvoření 100644 adresář1 / soubor4.txt

Pokud k vložení komentáře nepoužíváte volbu -m, Git otevře váš výchozí textový editor a požádá o něj. Komentáře jsou považovány za dobrou praxi v řízení verzí. Do odevzdání tedy vždy vložte smysluplné komentáře.

6. git config

Příkaz git config umožňuje nastavit různé možnosti úložiště git. Můžete například použít git config -global příkaz pro získání a nastavení uživatele.jméno a uživatel.e-mailem.

Zde můžete nastavit hodnoty:

$ git config - globální uživatel.jméno 'Zak H'
$ git config - globální uživatel.e-mail zakh @ příklad.com

Zde můžete zkontrolovat hodnoty:

$ git config - globální uživatel.název
Zak H
$ git config - globální uživatel.e-mailem
zakh @ příklad.com

7. git diff

Příkaz git diff vám pomůže vidět rozdíly mezi soubory a složkami. Pokud provádíte změny v souboru, je to užitečný nástroj pro rychlé vyhodnocení provedených změn.

Předpokládejme, že začneme s ReadMe.soubor txt se dvěma řádky. Pak se zbavíme druhého řádku a přidáme třetí řádek.

Nyní, když spustíme příkaz diff, zobrazí se rozdíly mezi potvrzenou verzí a lokálně změnou verzí v pracovní oblasti. Jak to bude vypadat:

$ git rozdíl
diff --git a / ReadMe.txt b / ReadMe.txt
index 9475ddc… 1804904 100644
--- a / ReadMe.txt
+++ b / ReadMe.txt
@@ -1,2 +1,2 @@
Řádek 1: Můj první řádek
-Řádek 2: Můj druhý řádek
+Řádek 3: Můj TŘETÍ řádek

Řádek 1 je nezměněn (bílý), řádek 2 odstraněn (červený) a řádek 3 přidán (zelený).
Příkaz diff můžete použít také k vyhledání rozdílů mezi konkrétními revizemi.

8. git načíst

Příkaz git fetch získá nejnovější zdroje ze zadaného původu.

Podívejme se na příklad. Předpokládáme, že máte následující stav:

dir1 / myproject
dir2 / myproject (klonovaný)

Složka 'dir2 / myproject' je klonována z 'dir1 / myproject'. Nyní, pokud někdo spáchal změny na 'dir1 / myproject', můžete tyto změny získat zevnitř 'dir2 / myproject':

$ git načíst původ
remote: Počítání objektů: 2, hotovo.
remote: Komprese objektů: 100% (2/2), hotovo.
dálkově: Celkem 2 (delta 0), znovu použito 0 (delta 0)
Vybalení předmětů: 100% (2/2), hotovo.
Z / dir2 /… / dir1 / myproject
5a0bd75… 1713734 hlavní -> počátek / hlavní

Je důležité si uvědomit, že příkaz git fetch nesloučí změny. Pro automatické načtení a sloučení použijte příkaz git pull. Pak se možná divíte, proč tento příkaz používat vůbec. Mohly by existovat pokročilé možnosti Git, kde získáte všechny změny ze svého původního serveru a pak použijete změny pouze selektivně na určité soubory. Toho lze dosáhnout pomocí příkazu git fetch. Je to však pokročilé téma, které najdete v dokumentaci git fetch.

9. git grep

Příkaz git grep umožňuje vyhledávat informace ve vašem Git stromu. Zde je příklad hledání slova „Line“ v našem git repozitáři. Možnost -n nebo --line-number zobrazuje čísla řádků, kde Git najde shodu:

$ git grep -n Řádek
ReadMe.txt: 1: Řádek 1: Můj první řádek
ReadMe.txt: 2: Řádek 3: Můj TŘETÍ řádek

Můžete spustit podobné vyhledávání, kolikrát je tam shoda s možností -c nebo --count:

git grep -c řádek
ReadMe.txt: 2

Důvodem použití git grep přes Linux grep je, že git grep je rychlejší pro git repozitáře.

10. git log

Příkaz git log vám ukáže historii potvrzení.

$ git log
spáchat 171373479fc309846ef605fbe650933767afd0fb
Autor: Zak H
Datum: St 21. listopadu 20:26:32 2018-0800
Byly přidány nové soubory
odevzdat 5a0bd759506d20b2b989873258bf60d003aa3d36
Autor: Zak H
Datum: St 21. listopadu 18:48:35 2018-0800
Inicializovat mé úložiště

Chcete-li zobrazit zkrácenou verzi, můžete také použít volbu --oneline. Zkrácená verze je snadnější sledovat.

$ git log - online
1713734 Byly přidány nové soubory
5a0bd75 Inicializovat mé úložiště

11. git sloučit

Příkaz git merge sloučí větve.

Pojďme vytvořit nové úložiště s 'main' a pak vytvoříme 'test' větev.

$ mkdir můj projekt
$ cd můj projekt
$ git init
Inicializované prázdné úložiště Git v / git_essentials / myproject /.git /
$ touch ReadMe.txt
$ git přidat -A
$ git commit -m 'Počáteční potvrzení'
[master (root-commit) b31d4e1] Počáteční potvrzení
1 soubor změněn, 0 vložení (+), 0 odstranění (-)
vytvořit režim 100644 ReadMe.txt
$ git test větve
$ git větev -a
* mistr
test
$ git pokladní test
Přepnuto na větev „test“

Ve větvi „test“ provedeme několik změn:

$ klepněte na Soubor1.Soubor txt2.txt
$ Ls
Soubor1.Soubor txt2.txt ReadMe.txt
$ git přidat -A
$ git commit -m 'Přidány dva nové soubory'
[test 7e11910] Přidány dva nové soubory
2 soubory změněny, 0 vložení (+), 0 odstranění (-)
vytvořit režim 100644 File1.txt
vytvořte režim 100644 File2.txt

Do testu jsme přidali dva soubory.

$ git větev -a
mistr
* test
$ ls
Soubor1.Soubor txt2.txt ReadMe.txt
$ git pokladna master
Přepnuto na větev „master“
$ git větev -a
* mistr
test
$ ls
ReadMe.txt

Z výše uvedeného vidíme, že File1.txt a File2.txt existuje ve větvi 'test', ale ne v 'master'.

Pojďme se spojit.

$ git test sloučení
Aktualizace b31d4e1… 7e11910
Rychle vpřed
Soubor1.txt | 0
Soubor2.txt | 0
2 soubory změněny, 0 vložení (+), 0 odstranění (-)
vytvořit režim 100644 File1.txt
vytvořte režim 100644 File2.txt
$ ls
Soubor1.Soubor txt2.txt ReadMe.txt
$ git větev -a
* mistr
test

Nyní máme 'File1.txt 'a' File2.txt také v „hlavní“ větvi.

Poznámka: Sloučení považujte za operaci stahování. Musíte být v oboru, do kterého chcete sloučit. V tomto případě jste ve větvi „master“ a stahujete změny z větve „test“.

12. git mv

Git mv je zkratka pro spuštění příkazů git add a git rm. Lze jej použít k přejmenování souborů.

Zde je příklad:

$ git mv ReadMe.txt ReadMe.md
stav $ git
Na pobočce
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
přejmenováno: ReadMe.txt -> ReadMe.md

13. git pull

Příkaz git pull se hodně podobá načtení git, kromě toho, že ke sloučení dochází automaticky.

Zde je příklad spuštění původu git pull, jako je git fetch one (spouštíme požadavek na tah z klonu, abychom získali změny z původního úložiště Git):

$ git pull origin
remote: Počítání objektů: 3, hotovo.
remote: Komprese objektů: 100% (2/2), hotovo.
remote: Celkem 3 (delta 0), znovu použito 0 (delta 0)
Vybalení předmětů: 100% (3/3), hotovo.
Z / LearnGIT / git_essentials / myproject
7e11910… e67f932 hlavní -> počátek / hlavní
Aktualizace 7e11910… e67f932
Rychle vpřed
Soubor1.txt | 1 +
Soubor2.txt | 1 +
Soubor3.txt | 1 +
ReadMe.txt => ReadMe.md | 0
4 soubory změněny, 3 vložení (+)
vytvořte režim 100644 File3.txt
přejmenovat ReadMe.txt => ReadMe.md (100%)

Vidíte, že změny byly staženy z počátku a sloučeny do klonu.

14. git push

Příkaz git push se používá k odeslání změn do vzdálených úložišť. Zde je příklad spuštění příkazu push:

$ git push Origin Master
Počítání objektů: 2, hotovo.
Delta komprese pomocí až 4 vláken.
Komprese objektů: 100% (2/2), hotovo.
Psaní objektů: 100% (2/2), 242 bajtů | 0 bajtů / s, hotovo.
Celkem 2 (delta 1), znovu použito 0 (delta 0)
Do / LearnGIT / git_essentials / myproject
e67f932… 90dc546 master -> master

Příkaz git push origin master posílá změny do „hlavní“ větve původu (repozitář Git, který jste naklonovali) z „hlavní“ větve klonovaného úložiště. Vizuálně push vypadá takto:

klonovaný / hlavní -> počátek / hlavní

15. git rebase

Příkaz git rebase vám pomůže změnit základnu větví. Při obecném sloučení se stane něco takového:

Testovací větev byla sloučena do větve 'master' za účelem vytvoření nového potvrzení.

Při rebase se to stane:

Změny ze seznamů změn E a F se přepočítají a zablokují na konci hlavní větve. Rebasing pomáhá zjednodušit pobočky.

Předpokládejme, že máme tuto situaci v „hlavní“ větvi:

$ git log - online
7f573d8 Commit C: přidáno c.txt
795da3c Commit B: přidáno b.txt
0f4ed5b Commit A: přidáno a.txt

A větev funkcí:

$ git log - online
8ed0c4e Commit F: změněno b.txt
6e12b57 Commit E: změněno a.txt
795da3c Commit B: přidáno b.txt
0f4ed5b Commit A: přidáno a.txt

Pokud rebase, dostaneme git rebase master:

Funkce $ git checkout
Přepnuto na větev „funkce“
$ git rebase master

Nejprve přetočte hlavu, aby se vaše práce přehrála ..

Použití: Potvrdit E: změněno a.txt
Použití: Potvrdit F: změněno b.txt
Poté sloučte 'funkci' do 'hlavní'.
$ git pokladna master
Přepnuto na větev „master“
Funkce $ git merge
Aktualizace 7f573d8… 9efa1a3
Rychle vpřed
A.txt | 1 +
b.txt | 1 +
2 soubory změněny, 2 vložení (+)

Nyní, pokud přejdete do větve 'master' a 'feature', uvidíte stejné protokoly:

$ git log - online
9efa1a3 Commit F: změněno b.txt
8710174 Commit E: změněno a.txt
7f573d8 Commit C: přidáno c.txt
795da3c Commit B: přidáno b.txt
0f4ed5b Commit A: přidáno a.txt

Rebasing je spojil dohromady.

Poznámka: Nikdy nepoužívejte rebasing ve veřejných úložištích, protože vývojáři narazí na velké problémy se slučováním.

16. git remote

Příkaz git remote vám umožňuje nastavit vzdálený server pro vaše úložiště. V klonovací situaci se zdrojové úložiště automaticky stane vzdáleným.

Například:

$ pwd
/ LearnGIT / git_essentials / test
$ git remote -v
origin / LearnGIT / git_essentials / myproject (načíst)
origin / LearnGIT / git_essentials / myproject (push)

Výše uvedené ukazuje, že vzdálený server pro „test“ je další složka s názvem „myproject“. Důvodem je, že ‚test 'byl klonován pro můj projekt.

Vzdálený server ale nemusí být místní. S adresou URL můžete mít něco takového:

$ git remote -v
původ https: // github.com / zakh / myproject (načíst)
původ https: // github.com / zakh / myproject (push)

Vzdálené úložiště git můžete nastavit pomocí příkazu git remote add :

$ git vzdálené přidání původu https: // github.com / zakh / myproject

Tím se vaše repo připojí k počátku, abyste mohli načítat a tlačit.

17. git reset

Git reset vám umožní přidat přidané soubory na scénu.

Řekněme, že jste přidali soubor 'test.txt 'do vašeho úložiště:

$ dotykový test.txt
$ git přidat -A
stav $ git
Na pobočce
Vaše pobočka je aktuální s „origin / master“.
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
nový soubor: test.txt

Rozhodnete se však, že test nechcete sledovat.txt 'už. Můžete použít hlavu git reset příkaz k unstage souboru:

$ git reset HEAD test.txt

Pokud zkontrolujete stav, soubor je opět nesledovaný:

stav $ git
Na pobočce
Vaše pobočka je aktuální s „origin / master“.
Nesledované soubory:
(použijte 'git add … “Zahrnout do toho, co bude spácháno)
test.txt

Souborový test.txt 'již není sledován.

18. git vrátit

Příkaz git revert umožňuje vrátit změny pomocí čísla hash potvrzení.

$ echo 'Test 1' >> MyFile.txt
$ git přidat -A
$ git commit -m 'Přidána změna 1'
[master 78a8277] Přidána změna 1
2 soubory změněny, 1 vložení (+)
vytvořit režim 100644 MyFile.txt
vytvořit režim 100644 test.txt
$ kočka MyFile.txt
Test 1
$ echo 'Test 2' >> MyFile.txt
$ git přidat -A
$ git commit -m 'Přidána změna 2'
[master a976e9c] Přidána změna 2
1 soubor změněn, 1 vložení (+)
$ kočka MyFile.txt
Test 1
Test 2
$ git log - online
a976e9c Přidána změna 2
78a8277 Přidána změna 1
90dc546 Přidán soubor
e67f932 Přidány nové soubory
7e11910 Přidány dva nové soubory
b31d4e1 Počáteční potvrzení

Vytvořili jsme 'MyFile.txt 'a spáchal dvě změny, takže soubor má řádky' Test 1 'a' Test 2 '. Ale rozhodli jsme se, že nechceme druhé potvrzení. Takže jsme našli hash pro potvrzení (a976e9c). Můžeme použít git revert zbavit se potvrzení:

$ git vrátit a976e9c
[master 4f270e7] Vrátit 'Přidána změna 2'
1 soubor změněn, 1 smazání (-)
$ git log - online
4f270e7 Vrátit 'Přidána změna 2'
a976e9c Přidána změna 2
78a8277 Přidána změna 1
90dc546 Přidán soubor
e67f932 Přidány nové soubory
7e11910 Přidány dva nové soubory
b31d4e1 Počáteční potvrzení
$ kočka MyFile.txt
Test 1

Vidíme, že byl vytvořen nový hash potvrzení, který vrátil potvrzení řádku „Test 2“. Soubor má nyní pouze řádek „Test 1“.

19. git rm

Příkaz git rm nastavuje soubory pro budoucí mazání. Umístí soubory, které mají být odstraněny, v pracovní oblasti.

$ git rm test.txt
rm 'test.txt '
stav $ git
Na pobočce
Vaše pobočka je před „původem / pánem“ o 3 závazky.
(k publikování místních závazků použijte 'git push')
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
smazáno: test.txt

Změny se projeví až po potvrzení změn.

20. git skrýš

Příkaz git stash vám umožňuje dočasně opustit práci, kterou ještě nejste připraveni spáchat.
Předpokládejme, že pracujete v úložišti s následujícími soubory:

$ ls
John.txt Mary.txt
Chcete tyto soubory změnit, aby byly více projektové. Takže začnete s:
$ git mv John.txt ProjectFile1.txt
$ ls
Mary.txt ProjectFile1.txt
stav $ git
Na pobočce
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
přejmenován: John.txt -> ProjectFile1.txt

Uprostřed přejmenování a aktualizace „John.txt 'do' ProjectFile1.txt ', obdržíte požadavek na něco změnit v projektu. Ale nejste připraveni odeslat 'ProjectFile1.txt '. Takže to schovejte.

$ git skrýš

Uložený pracovní adresář a stav indexu WIP na hlavní: f0b5a01 Init John and Mary

HEAD je nyní na f0b5a01 Init John and Mary

$ ls
John.txt Mary.txt

Vaše místní pracovní prostředí je zpět tam, kde jste byli před provedením změn založených na projektu. Poté, místo toho, abych se vrátil k „Johnu, jsem se vypořádal s přerušením.txt ', rozhodnete se pracovat na' Mary.Soubor txt 'nyní:

$ git mv Mary.txt ProjectFile2.txt
stav $ git
Na pobočce
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
přejmenováno: Mary.txt -> ProjectFile2.txt
$ ls
John.txt ProjectFile2.txt

Znovu vás vyruší a uložíte svou novou práci na Mary.txt ':

$ git skrýš
Uložený pracovní adresář a stav indexu WIP na hlavní: f0b5a01 Init John and Mary
HEAD je nyní na f0b5a01 Init John and Mary
$ ls
John.txt Mary.txt

Po dokončení práce na přerušení zkontrolujete seznam schovaných položek:

$ git stash seznam
stash @ 0: WIP on master: f0b5a01 Init John and Mary
stash @ 1: WIP na masteru: f0b5a01 Init John and Mary

Ve skrýši máte dva rozpracované produkty (WIP). Jednoduše, když vyskočíte na skrýš, dostanete nejnovější 'Mary.txt 'změny:

$ git stash pop
Odstraňování Mary.txt
Na pobočce
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
nový soubor: ProjectFile2.txt
Změny, které nebyly provedeny pro potvrzení:
(použijte 'git add / rm … “K aktualizaci toho, co bude spácháno)
(použijte 'git checkout -- … “Pro zahození změn v pracovním adresáři)
vypouští se: Mary.txt
Zrušené doporučení / uložení @ 0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

Podruhé, když vyskočíte na skrýš, dostanete 'Johna.Změny související s txt':

$ git stash pop
Odstraňování Johna.txt
Na pobočce
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
nový soubor: ProjectFile1.txt
nový soubor: ProjectFile2.txt
Změny, které nebyly provedeny pro potvrzení:
(použijte 'git add / rm … “K aktualizaci toho, co bude spácháno)
(použijte 'git checkout -- … “Pro zrušení změn v pracovním adresáři)
smazáno: John.txt
vypouští se: Mary.txt
Zrušené doporučení / uložení @ 0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ ls
ProjectFile1.txt ProjectFile2.txt

A máte svůj rozpracovaný 'ProjectFile1.txt 'a' ProjectFile2.txt 'zpět.

Příkaz git stash vám tedy pomůže uschovat vaši práci, abyste se k ní mohli později vrátit.

21. stav git

Příkaz git status zobrazuje rozdíl mezi aktuálními soubory a potvrzením HEAD.

Zde je příklad:

stav $ git
Na pobočce
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
přejmenováno: File2.txt -> Soubor3.txt
Změny nebyly provedeny pro potvrzení:
(použijte 'git add … “K aktualizaci toho, co bude spácháno)
(použijte 'git checkout -- … “Pro zahození změn v pracovním adresáři)
upraveno: Soubor1.txt

Ukazuje to 'File2.txt 'se přejmenovává na' File3.txt ', který je připraven ke spáchání, ale úpravy v' File1.txt 'ještě není v pracovní oblasti.

Přidáme tedy vše:

$ git přidat -A

Nyní, když kontrolujeme stav:

stav $ git
Na pobočce
Provedené změny:
(použijte 'git reset HEAD … “Na scénu)
upraveno: Soubor1.txt
přejmenováno: File2.txt -> Soubor3.txt

Vidíme, že všechny změny jsou připraveny k potvrzení.

22. značka git

Příkaz git tag vám pomůže vytvořit značky pro vaše důležité historické body. Obvykle se používá k nastavení čísel verzí.

Příkaz git tag vám ukáže aktuální dostupné tagy:

$ git tag
v1.0
v2.0

Můžete označit tagem formátu příkazu git :

$ git tag v3.0

Chcete-li zjistit, co je ve značce, můžete použít příkaz git show:

$ git show v1.0
spáchat 61e9e8aa1b98b2a657303e6822b291d2374314b5
Autor: Zak H
Datum: Čt 22. listopadu 01:06:42 2018-0800
První potvrzení
diff --git a / 1.txt b / 1.txt
nový režim souborů 100644
index 0000000… e69de29

Můžete také označit pomocí hash potvrzení a značky formátu git příkazu :

$ git log - online
374efe9 Upravený soubor
a621765 Přidat
6d6ed84 Druhé potvrzení
61e9e8a První potvrzení
$ git tag v4.0 a621765
$ git show v4.0
spáchat a6217650a2c7b2531ecb9c173ba94bd4b3ba7abd
Autor: Zak H
Datum: Čt 22. listopadu 01:15:55 2018-0800
Přidat
diff --git a / 1.txt b / 1.txt
index e69de29… 587be6b 100644
--- a / 1.txt
+++ b / 1.txt
@@ -0,0 +1 @@

Závěrem

Pro libovolný příkaz můžete použít git -h získat více informací.

Další studie

https: // git-scm.com / dokumenty