Top 10 comandi GIT essenziali

Git è diventato il sistema di controllo della versione per eccellenza. L'ascesa della popolarità di Git può essere attribuita alla sua velocità, agilità e versatilità. Che tu sia uno sviluppatore web freelance o un progettista di software per applicazioni a livello aziendale, puoi beneficiare dell'utilizzo di GIT. Ti aiuta a tenere traccia dei tuoi file attraverso la versione sistematica. Git semplifica il roll-back alle versioni precedenti del codice o creare nuovi filiali per sperimentare la base di codice corrente. Inoltre, Git è un sistema di controllo della versione distribuita, il che significa che non devi sempre connetterti a un server centrale per svolgere il tuo lavoro.Di seguito sono riportati i comandi GIT essenziali che ti aiuteranno nelle attività quotidiane. I semplici esempi ti daranno una comprensione dei comandi, quindi puoi facilmente ricordare la sintassi quando è necessario usarli.

1. git aggiungi

Il comando ADD GIT ti consente di avviare file di tracciamento e cartelle per il tuo repository Git e li sposta nell'area di gestione temporanea. Dovrai utilizzare il comando di commit git per renderli permanenti nelle tue istantanee storiche.

L'uso del comando è facile. È possibile scegliere di aggiungere file e cartelle individualmente o utilizzare l'operatore glob di tipo Linux (*) per aggiungerli in gruppi.

Prendiamo l'esempio di seguito:

Supponiamo, nel caso sopra, abbiamo già aggiunto il Readme.TXT. Ma il resto dei file non è stato aggiunto.

Controlliamo lo stato:

$ git status
Su Branch Master
La tua filiale è aggiornata con "origine/master".
File non tracciati:
(Usa 'git aggiungi…' da includere in ciò che sarà impegnato)
File1.TXT
file2.TXT
cartella1/

I file e le cartelle sono in rosso, il che significa che non vengono tracciati. Possiamo aggiungerli usando:

$ git aggiungi file1.txt file2.TXT Folder1/*

Se controlliamo lo stato ora:

$ git status
Su Branch Master
La tua filiale è aggiornata con "origine/master".
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Nuovo file: file1.TXT
Nuovo file: file2.TXT
Nuovo file: cartella1/file3.TXT
Nuovo file: cartella1/file4.TXT

Il comando Git Add ha aggiunto i file all'area di gestione temporanea. I file sono conservati nell'area di stadiazione prima di renderli permanenti attraverso il processo di commit.

2. GIT Branch

Su Git, la ramificazione è facile. In altri sistemi di controllo della versione, è stata un'operazione costosa. Ma gli algoritmi GIT sono ottimizzati per la ramificazione. Quindi puoi utilizzare il comando Git Branch ogni volta che si desidera creare una linea di sviluppo separata senza preoccuparti delle prestazioni.

Diamo un'occhiata al seguente esempio.

$ git status
Su Branch Master
La tua filiale è aggiornata con "origine/master".
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Nuovo file: file1.TXT
Nuovo file: file2.TXT
Nuovo file: cartella1/file3.TXT
Nuovo file: cartella1/file4.TXT

Si noti che siamo "su Branch Master". Quando crei un nuovo progetto, finirai in Branch Master. Puoi anche usare il comando GIT -A per scoprire su quale ramo sei:

$ git branch -a
* maestro

Quanto sopra ti dice che c'è un solo ramo chiamato "Master" e l'Asterisk (*) significa che sei su quel ramo.

Creiamo un nuovo ramo chiamato "Test":

$ git branch testing

Ora possiamo controllare di nuovo i rami:

$ git branch -a
* maestro
Test

Anche se siamo ancora sul ramo "maestro", possiamo anche vedere il nuovo ramo "test" che è stato creato. Il ramo "Test" è una replica del ramo "Master".

3. Checkout Git

Il comando Git Checkout ti porta in una filiale, in modo da poter lavorare sulle risorse lì dentro. Puoi pensare ai rami come fiumi e flussi. Con un ramo, crei un nuovo flusso. Con il comando checkout, ti sposta in quel flusso.

Facciamo un'occhiata al ramo "Test" dall'esempio precedente:

$ git checkout test
Passato al ramo "test"

Ora controlliamo di nuovo lo stato e le filiali:

$ git status
Sui test di ramo
Niente da impegnare, la directory di lavoro pulita
$ git branch -a
maestro
* Test

Puoi vedere dal comando Git -A che abbiamo spostato nel ramo di test.

4. clone git

Il comando clone git consente di fare una copia di qualsiasi repository git. Non appena clona un repository, la nuova cartella clonata inizierà a tenere traccia delle modifiche a livello locale. Poiché Git è distribuito, un clone è un repository GIT completamente autonomo.

Per mostrare come funziona la clonazione, creiamo un nuovo repository:

$ MKDIR DIR1
$ cd dir1
$ mkdir myproject
$ cd myproject/
$ git init
Repository git vuoto inizializzato in/dir1/myproject/.idiota/
$ touch readme.TXT
$ git commit -m 'inizializza il mio repository'
[Master (root-commit) 5a0bd75] Inizializza il mio repository
1 file modificato, 0 inserzioni (+), 0 delezioni (-)
Crea modalità 100644 Readme.TXT

Nell'esempio sopra, abbiamo creato un repository git chiamato "MyProject" all'interno della cartella dir1. Supponiamo, questo è il nostro repository principale. Ora vogliamo farne una copia e lavorare altrove.

Creiamo una directory chiamata "dir2" e clone il repository "myproject". Stiamo usando il clone git per clone "myproject":

$ MKDIR DIR2
$ cd dir2
$ git clone/dir1/myproject/
Cloning in "myproject" ..
Fatto.
$ ls
il mio progetto

Il comando clone git funziona anche con un URL.

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

Inoltre, è possibile modificare il nome del clone specificandolo dopo l'indirizzo del repository Git:

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

5. commit git

Il comando di commit git viene eseguito dopo il comando Git Aggiungi. Nel nostro esempio di Git, avevamo aggiunto i file per il monitoraggio, ma non l'abbiamo impegnato nel repository Git. Il monitoraggio rimane locale fino a quando non viene effettuato un commit. Quando commetti i cambiamenti, diventano parte del record permanente.

Di seguito stiamo eseguendo il comando git commit -m:

$ git commit -m "commettere i miei file e cartelle"
[Master 3ef57b3] Committendo i miei file e cartelle
4 file modificati, 0 inserzioni (+), 0 delezioni (-)
Crea modalità 100644 File1.TXT
Crea modalità 100644 File2.TXT
Crea modalità 100644 Cartella1/File3.TXT
Crea modalità 100644 Cartella1/File4.TXT

Se non usi l'opzione -m per mettere un commento, Git aprirà il tuo editor di testo predefinito e lo chiederà. I commenti sono considerati una buona pratica di controllo della versione. Quindi metti sempre commenti significativi nel tuo commit.

6. config git

Il comando Git Config ti consente di impostare varie opzioni per il tuo repository Git. Ad esempio, è possibile utilizzare il comando Git Config -Global per ottenere e impostare il tuo utente.Nome e utente.e-mail.

Ecco come è possibile impostare i valori:

$ git config -utente global.Nome 'Zak H'
$ git config -utente global.Email [email protected]

Ecco come puoi controllare i valori:

$ git config -utente global.nome
Zak H
$ git config -utente global.e-mail
[email protected]

7. git diff

Il comando Git Diff ti aiuta a vedere le differenze tra file e cartelle. Se stai apportando modifiche in un file, è uno strumento utile per valutare rapidamente le modifiche apportate.

Supponiamo che iniziamo il nostro lavoro con un readme.file txt con due righe. Quindi ci sbarazziamo della seconda riga e aggiungiamo una terza riga.

Ora, se eseguiamo il comando diff, mostrerà le differenze tra la versione impegnata e la versione modificata locale nell'area di messa in scena. Ecco come apparirà:

$ git diff
Diff --Git A/Readme.txt b/readme.TXT
INDICE 9475DDC… 1804904 100644
--- a/readme.TXT
+++ b/readme.TXT
@@ -1,2 +1,2 @@
Riga 1: la mia prima riga
-Riga 2: la mia seconda riga
+Riga 3: la mia terza riga

La linea 1 è invariata (bianca), la linea 2 rimossa (rosso) e la linea 3 aggiunte (verde).
È possibile utilizzare il comando diff per trovare anche differenze tra commessi particolari.

8. Git Fetch

Il comando Git Fetch ottiene le ultime risorse dall'origine specificata.

Diamo un'occhiata a un esempio. Supponi di avere la seguente condizione:

dir1/myproject
Dir2/MyProject (clonato)

La cartella "Dir2/MyProject" è clonata da "Dir1/MyProject". Ora se qualcuno ha commesso modifiche a "DIR1/MyProject", puoi ottenere quei cambiamenti come questo dall'interno "DIR2/MyProject":

$ git prevedere origine
remoto: conteggio degli oggetti: 2, fatto.
Remoto: oggetti di compressione: 100% (2/2), fatto.
Remoto: totale 2 (Delta 0), riutilizzato 0 (Delta 0)
Disimballaggi Oggetti: 100% (2/2), fatto.
Da /dir2 /… /dir1 /myproject
5a0bd75… 1713734 Master -> Origin/Master

È importante ricordare che il comando Git Fetch non unisce le modifiche. Per recuperare e unire automatici, usa il comando Git pull. Allora potresti chiederti perché utilizzare questo comando in primo luogo. Potrebbero esserci opzioni GIT avanzate in cui si ottengono tutte le modifiche dal server di origine e quindi si applicano solo le modifiche selettivamente su determinati file. Il comando Git Fetch ti consente di raggiungere questo obiettivo. Tuttavia, è un argomento avanzato che puoi trovare nella documentazione di Git Fetch.

9. git grep

Il comando Git Grep ti consente di cercare informazioni sul tuo albero GIT. Ecco un esempio di ricerca della parola "riga" nel nostro repository git. L'opzione -N o -Line -Number mostra i numeri di riga in cui Git trova una corrispondenza:

$ git grep -n line
Readme.txt: 1: riga 1: la mia prima riga
Readme.txt: 2: riga 3: la mia terza riga

È possibile eseguire una ricerca simile per il numero di volte in cui la corrispondenza è lì con l'opzione -c o -count:

linea git grep -c
Readme.txt: 2

Il motivo per l'uso di Git Grep su Linux Grep è che Git Grep è più veloce per i repository Git.

10. registro git

Il comando del registro Git mostra la cronologia di commit.

$ git log
commit 171373479fc309846ef605fbe650933767afd0fb
Autore: Zak H
Data: mer 21 novembre 20:26:32 2018 -0800
Nuovi file aggiunti
commit 5a0bd759506d20b2b989873258bf60d003aa3d36
Autore: Zak H
Data: mer 21 novembre 18:48:35 2018 -0800
Inizializza il mio repository

Puoi anche utilizzare l'opzione --Oneline per vedere una versione abbreviata. La versione abbreviata è più facile da seguire.

$ git log --oneline
1713734 nuovi file aggiunti
5a0bd75 Inizializza il mio repository

11. Git unire

Il comando Git Merge unisce i rami.

Creiamo un nuovo repository con "main" e quindi creiamo un ramo "test".

$ mkdir myproject
$ cd myproject
$ git init
Repository git vuoto inizializzato in/git_essentials/myproject/.idiota/
$ touch readme.TXT
$ git aggiungi -a
$ git commit -m "commit iniziale"
[Master (Root-Commit) B31D4E1] Committe iniziale
1 file modificato, 0 inserzioni (+), 0 delezioni (-)
Crea modalità 100644 Readme.TXT
$ git branch test
$ git branch -a
* maestro
test
$ Git Checkout Test
Passato al ramo "test"

Nel ramo "Test", apportiamo alcune modifiche:

$ touch file1.txt file2.TXT
$ Ls
File1.txt file2.txt readme.TXT
$ git aggiungi -a
$ git commit -m 'ha aggiunto due nuovi file'
[Test 7E11910] ha aggiunto due nuovi file
2 file modificati, 0 inserzioni (+), 0 delezioni (-)
Crea modalità 100644 File1.TXT
Crea modalità 100644 File2.TXT

Abbiamo aggiunto due file al test.

$ git branch -a
maestro
* test
$ ls
File1.txt file2.txt readme.TXT
$ git checkout master
Passato a Branch 'Master'
$ git branch -a
* maestro
test
$ ls
Readme.TXT

Vediamo da quanto sopra, quel file1.txt e file2.TXT esiste nel ramo "Test", ma non in "Master".

Unisciti ora.

$ git unire test
Aggiornamento di B31D4E1… 7E11910
Avanti veloce
File1.txt | 0
File2.txt | 0
2 file modificati, 0 inserzioni (+), 0 delezioni (-)
Crea modalità 100644 File1.TXT
Crea modalità 100644 File2.TXT
$ ls
File1.txt file2.txt readme.TXT
$ git branch -a
* maestro
test

Ora abbiamo 'file1.txt 'e' file2.txt "in" maestro "anche.

Nota: pensa a unire come un'operazione di trazione. Devi essere nel ramo in cui vuoi fonderti. In questo caso, sei nel ramo "Master" che tira le modifiche dal ramo "test".

12. git mv

Il Git MV è un comando a corto di taglio per eseguire i comandi Git Add e Git RM. Può essere utilizzato per rinominare i file.

Ecco un esempio:

$ git mv readme.txt readme.MD
$ git status
Su Branch Master
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Rinominato: Readme.txt -> readme.MD

13. git tira

Il comando git pull è molto simile al recupero git, tranne che l'accusa avviene automaticamente.

Ecco un esempio di Origine Git Pull come quella git prese (stiamo eseguendo una richiesta di pull dal clone per ottenere modifiche dal repository Git originale):

$ git pull origin
remoto: conteggio degli oggetti: 3, fatto.
Remoto: oggetti di compressione: 100% (2/2), fatto.
Remoto: totale 3 (Delta 0), riutilizzato 0 (Delta 0)
Disimballaggi Oggetti: 100% (3/3), fatto.
Da/learngit/git_essentials/myproject
7E11910… E67F932 MASTER -> Origine/Master
Aggiornamento 7E11910… E67F932
Avanti veloce
File1.txt | 1 +
File2.txt | 1 +
File3.txt | 1 +
Readme.txt => readme.MD | 0
4 file modificati, 3 inserzioni (+)
Crea modalità 100644 File3.TXT
Rinomina Readme.txt => readme.MD (100%)

Puoi vedere che le modifiche sono state scaricate dall'origine e si sono unite nel clone.

14. Git Push

Il comando Git Push viene utilizzato per spingere le modifiche ai repository remoti. Ecco un esempio di esecuzione del comando push:

$ git Push Origin Master
Contare gli oggetti: 2, fatto.
Compressione delta usando fino a 4 thread.
Oggetti di compressione: 100% (2/2), fatto.
Oggetti di scrittura: 100% (2/2), 242 byte | 0 byte/s, fatto.
Totale 2 (Delta 1), riutilizzato 0 (Delta 0)
A/apprendimento/git_essentials/myproject
E67F932… 90DC546 MASTER -> MASTER

Il comando Git Push Origin Master sta inviando modifiche al ramo "Master" dell'origine (il repository git clonati) dal ramo "master" del repository clonato. Visivamente, la spinta sembra così:

clonato/master -> origine/maestro

15. git rebase

Il comando Git Rebase ti aiuta a cambiare la base dei rami. In una fusione generale, succede qualcosa del genere:

Il ramo di prova è stato unito al ramo "Master" per creare un nuovo commit.

In una Rebase, questo è ciò che accade:

Le modifiche di E e F Changelist vengono ricalcolate e bloccate alla fine del ramo principale. Il ribasso aiuta a semplificare i rami.

Supponiamo che abbiamo questa situazione nel ramo "Master":

$ git log --oneline
7f573d8 commit c: aggiunto c.TXT
795DA3C Commit B: aggiunto B.TXT
0f4ed5b commit a: aggiunto a.TXT

E un ramo di funzionalità:

$ git log --oneline
8ed0c4e commit f: modificato B.TXT
6e12b57 commit e: modificato a.TXT
795DA3C Commit B: aggiunto B.TXT
0f4ed5b commit a: aggiunto a.TXT

Se ribelliamo, otteniamo Git Rebase Master:

Funzione $ Git Checkout
Cambia alla funzione di ramo "
$ git rebase master

Innanzitutto, riavvolgendo la testa per riprodurre il tuo lavoro sopra ..

Applicazione: commit e: modificato a.TXT
Applicazione: commit f: modificato B.TXT
Quindi unisci "funzione" in "Master".
$ git checkout master
Passato a Branch 'Master'
Funzione $ Git Merge
Aggiornamento di 7f573d8… 9efa1a3
Avanti veloce
UN.txt | 1 +
B.txt | 1 +
2 file modificati, 2 inserzioni (+)

Ora se vai al ramo "Master" e "Funzione", vedrai gli stessi registri:

$ git log --oneline
9EFA1A3 commit f: modificato B.TXT
8710174 commit e: modificato a.TXT
7f573d8 commit c: aggiunto c.TXT
795DA3C Commit B: aggiunto B.TXT
0f4ed5b commit a: aggiunto a.TXT

Rebasing li ha schiacciati insieme.

Nota: non usare mai il rebilazione nei repository pubblici poiché gli sviluppatori si imbatteranno in importanti problemi di unione.

Git Remote

Il comando remoto Git consente di impostare un server remoto per il tuo repository. In una situazione di clonazione, il repository di origine diventa automaticamente il telecomando.

Per esempio:

$ pwd
/LearnGit/git_essentials/test
$ git remote -v
Origin/LearnGit/Git_essentials/myProject (Fetch)
Origin/LearnGit/Git_essentials/myProject (push)

Quanto sopra mostra che il server remoto per "test" è un'altra cartella chiamata "myproject". Il motivo è che il "test" è stato clonato per il mio progetto.

Ma il server remoto non deve essere locale. Puoi avere qualcosa di simile con un URL:

$ git remote -v
origine https: // github.com/zakh/myProject (Fetch)
origine https: // github.com/zakh/myproject (push)

È possibile impostare un repository remoto Git utilizzando il telecomando Git comando:

$ git remote aggiungi origine https: // github.com/zakh/myproject

Questo collegherà il tuo repository all'origine in modo da poter prendere e spingere.

17. reset git

Il reset GIT consente di spostarsi i file aggiunti.

Supponiamo che tu abbia aggiunto il test '.txt 'al tuo repository:

$ touch test.TXT
$ git aggiungi -a
$ git status
Su Branch Master
La tua filiale è aggiornata con "origine/master".
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Nuovo file: test.TXT

Tuttavia, decidi di non voler tracciare il test.txt 'più. È possibile utilizzare il comando GIT Reset Head per scendere il file:

$ git reset head test.TXT

Se controlli lo stato, il file è di nuovo non tracciato:

$ git status
Su Branch Master
La tua filiale è aggiornata con "origine/master".
File non tracciati:
(Usa 'git aggiungi…' da includere in ciò che sarà impegnato)
test.TXT

Il test del file.txt 'non viene più monitorato.

18. Git Ripristina

Il comando Git Revert consente di invertire le modifiche utilizzando il numero di commit hash.

$ echo 'test 1' >> myfile.TXT
$ git aggiungi -a
$ git commit -m 'ha aggiunto il cambiamento 1'
[Master 78A8277] Aggiunta modifica 1
2 file modificati, 1 inserimento (+)
Crea modalità 100644 myfile.TXT
Crea la modalità 100644 Test.TXT
$ cat myfile.TXT
Test 1
$ echo 'test 2' >> myfile.TXT
$ git aggiungi -a
$ git commit -m 'ha aggiunto il cambiamento 2'
[Master A976E9C] Aggiunta modifica 2
1 file modificato, 1 inserzione (+)
$ cat myfile.TXT
Test 1
Test 2
$ git log --oneline
a976e9c ha aggiunto la modifica 2
78A8277 Aggiunto la modifica 1
90dc546 ha aggiunto un file
E67F932 ha aggiunto nuovi file
7e11910 ha aggiunto due nuovi file
B31D4E1 Committe iniziale

Abbiamo creato un 'myfile.txt 'e impegnato due modifiche, quindi il file ha le righe "test 1" e "test 2". Ma abbiamo deciso che non vogliamo il secondo commit. Quindi abbiamo trovato il commit hash (A976e9c) per questo. Possiamo usare il ripristino GIT per sbarazzarci del commit:

$ git Revert A976E9C
[Master 4F270E7] Ripristina 'Aggiunta modifica 2'
1 file modificato, 1 eliminazione (-)
$ git log --oneline
4f270e7 Ripristina 'Aggiunta modifica 2'
a976e9c ha aggiunto la modifica 2
78A8277 Aggiunto la modifica 1
90dc546 ha aggiunto un file
E67F932 ha aggiunto nuovi file
7e11910 ha aggiunto due nuovi file
B31D4E1 Committe iniziale
$ cat myfile.TXT
Test 1

Vediamo che è stato creato un nuovo hash commit che ha riportato il commit "test 2". Il file ha solo la riga "test 1" ora.

19. git rm

Il comando Git RM imposta i file per eliminazioni future. Mette i file per essere definiti nell'area di stadiazione.

$ git rm test.TXT
RM 'Test.TXT'
$ git status
Su Branch Master
La tua filiale è davanti a "Origin/Master" di 3 commit.
(Usa 'Git Push' per pubblicare i commit locali)
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Eliminato: test.TXT

Devi commettere le modifiche per la cancellazione per avere effetto.

20. Git Stash

Il comando Git Stash ti consente di abbandonare temporaneamente il lavoro che non sei ancora pronto a impegnarti.
Supponiamo che tu stia lavorando in un repository con i seguenti file:

$ ls
John.txt Mary.TXT
Vuoi cambiare questi file per essere più basati su progetti. Quindi inizi con:
$ git mv John.TXT ProjectFile1.TXT
$ ls
Maria.TXT ProjectFile1.TXT
$ git status
Su Branch Master
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Rinominato: John.txt -> ProjectFile1.TXT

Nel mezzo di rinominare e aggiornare "John.txt 'to' ProjectFile1.txt ', ricevi una richiesta per cambiare qualcosa nel progetto. Ma non sei pronto a inviare "ProjectFile1.TXT'. Quindi lo metti.

$ git stash

Directory di lavoro salvata e WIP di stato indice su Master: F0B5A01 Init John e Mary

La testa è ora a F0B5A01 Init John e Mary

$ ls
John.txt Mary.TXT

Il tuo ambiente di lavoro locale è tornato a dove eri prima di apportare le modifiche basate sul progetto. Dopo, partecipare all'interruzione, invece di tornare da "John.txt ', decidi di lavorare sulla "Mary.TXT 'FILE ORA:

$ git mv mary.TXT ProjectFile2.TXT
$ git status
Su Branch Master
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Rinominato: Mary.txt -> ProjectFile2.TXT
$ ls
John.TXT ProjectFile2.TXT

Vieni di nuovo interrotto e metti a poppa il tuo nuovo lavoro su "Mary.TXT':

$ git stash
Directory di lavoro salvata e WIP di stato indice su Master: F0B5A01 Init John e Mary
La testa è ora a F0B5A01 Init John e Mary
$ ls
John.txt Mary.TXT

Dopo aver terminato il lavoro di interruzione, controlli l'elenco di scorte:

$ Git Stash List
Stash@0: WIP on Master: F0B5A01 Init John e Mary
Stash@1: WIP on Master: F0B5A01 Init John e Mary

Hai due work-in-progress (WIP) nella scorta. FIRS TEMPO PAPO LA SSHSH, ottieni l'ultima "Mary.TXT 'Modifiche:

$ git stash pop
Rimozione di Mary.TXT
Su Branch Master
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Nuovo file: ProjectFile2.TXT
Cambiamenti non messi in scena per commit:
(Usa 'git add/rm…' per aggiornare ciò che verrà impegnato)
(Utilizza 'Git Checkout -…' per eliminare le modifiche nella directory di lavoro)
Eliminato: Mary.TXT
Riforniti/stash rilasciati@0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

Seconda volta che fai scoppiare la scorta, ottieni il "John.Cambiamenti legati a txt's:

$ git stash pop
Rimozione di John.TXT
Su Branch Master
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Nuovo file: ProjectFile1.TXT
Nuovo file: ProjectFile2.TXT
Cambiamenti non messi in scena per commit:
(Usa 'git add/rm…' per aggiornare ciò che verrà impegnato)
(Utilizza 'Git Checkout -…' per eliminare le modifiche nella directory di lavoro)
Eliminato: John.TXT
Eliminato: Mary.TXT
Riforniti/stash rilasciati@0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ ls
ProjectFile1.TXT ProjectFile2.TXT

E hai il tuo progetto di lavoro in programma.txt 'e' ProjectFile2.txt 'back.

Quindi il comando Git Stash ti aiuta a riporre il tuo lavoro in modo da poterlo tornare più tardi.

21. Stato Git

Il comando di stato GIT visualizza la differenza tra i file correnti e il commit di testa.

Ecco un esempio:

$ git status
Su Branch Master
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
Rinominato: file2.txt -> file3.TXT
Cambiamenti non messi in scena per commit:
(Usa 'git aggiungi…' per aggiornare ciò che verrà impegnato)
(Utilizza 'Git Checkout -…' per eliminare le modifiche nella directory di lavoro)
modificato: file1.TXT

Sta dimostrando che 'file2.txt 'viene rinominato "file3.txt 'che è pronto per il commit, ma le modifiche in' file1.txt 'non è ancora nell'area di stadiazione.

Quindi, aggiungiamo tutto:

$ git aggiungi -a

Ora quando controlliamo lo stato:

$ git status
Su Branch Master
Modifiche da commettere:
(Usa la testa "git reset ..." per unstage)
modificato: file1.TXT
Rinominato: file2.txt -> file3.TXT

Vediamo che tutte le modifiche sono pronte per il commit.

22. Tag Git

Il comando Tag Git ti aiuta a creare tag per i tuoi importanti punti storici. Viene generalmente utilizzato per impostare i numeri di versione.

Il comando Tag Git ti mostrerà i tag attuali:

$ git tag
v1.0
v2.0

È possibile taggare con il tag GIT del formato di comando:

$ git tag v3.0

Per vedere cosa c'è nel tag, puoi usare il comando Git Show:

$ git show v1.0
commit 61e9e8aa1b98b2a657303e6822b291d2374314b5
Autore: Zak H
Data: GI 22 novembre 01:06:42 2018 -0800
Primo commit
Diff --Git A/1.txt b/1.TXT
Nuova modalità file 100644
INDICE 0000000 ... E69DE29

Puoi anche taggare usando un commit hash e il tag del formato di comando:

$ git log --oneline
374efe9 file modificato
A621765 ADD
6d6ed84 Second Commit
61e9e8a Primo commit
$ git tag v4.0 A621765
$ git show v4.0
commettere A6217650A2C7B2531ECB9C173BA94BD4B3BA7ABD
Autore: Zak H
Data: GI 22 novembre 01:15:55 2018 -0800
Aggiungere
Diff --Git A/1.txt b/1.TXT
INDICE E69DE29… 587Be6B 100644
--- A/1.TXT
+++ B/1.TXT
@@ -0,0 +1 @@

Insomma

Per qualsiasi comando, puoi usare Git -h per ottenere maggiori informazioni.

Ulteriori studi

• https: // git-scm.com/docs