22 Comandi Git essenziali

Git è diventato il sistema di controllo della versione per eccellenza. L'aumento della popolarità di Git può essere attribuito alla sua velocità, agilità e versatilità. Che tu sia uno sviluppatore web freelance o un progettista di software per applicazioni di livello aziendale, puoi trarre vantaggio dall'utilizzo di Git. Ti aiuta a tenere traccia dei tuoi file attraverso il versionamento sistematico. Git semplifica il rollback alle versioni precedenti del codice o la creazione di nuovi rami per sperimentare sulla base di codice corrente. Inoltre, Git è un sistema di controllo della versione distribuito, 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 tue attività quotidiane. I semplici esempi ti daranno una comprensione dei comandi, così puoi ricordare facilmente la sintassi quando devi usarli.

1. git add

Il comando git add ti consente di iniziare a tenere traccia di file e cartelle per il tuo repository Git e di spostarli nell'area di staging. Dovrai usare il comando git commit per renderli permanenti sulle tue istantanee storiche.

Usare il comando è facile. Puoi scegliere di aggiungere file e cartelle singolarmente o utilizzare l'operatore glob di tipo asterisco (*) di Linux per aggiungerli in gruppi.

Prendiamo l'esempio qui sotto:

Supponiamo, nel caso precedente, di aver già aggiunto il ReadMe.TXT. Ma il resto dei file non è stato aggiunto.

Controlliamo lo stato:

$git status
Sul maestro di filiale
La tua filiale è aggiornata con 'origine/master'.
File non tracciati:
(usa 'git add …' 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 cartella1/*

Se controlliamo lo stato ora:

$git stato
Sul maestro di filiale
La tua filiale è aggiornata con 'origine/master'.
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
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 staging. I file vengono conservati nell'area di staging prima di renderli permanenti attraverso il processo di commit.

2. git branch

Su Git, il branch è facile. In altri sistemi di controllo della versione, era un'operazione costosa. Ma gli algoritmi Git sono ottimizzati per il branching. Quindi puoi usare il comando git branch ogni volta che vuoi creare una linea di sviluppo separata senza preoccuparti delle prestazioni.

Diamo un'occhiata al seguente esempio.

$git stato
Sul maestro di filiale
La tua filiale è aggiornata con 'origine/master'.
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
nuovo file:   file1.TXT
nuovo file: file2.TXT
nuovo file:   cartella1/file3.TXT
nuovo file:   cartella1/file4.TXT

Nota che siamo 'On branch master'. Quando crei un nuovo progetto, finirai in branch master branch. Puoi anche usare il comando git branch -a per scoprire su quale ramo ti trovi:

$git ramo -a
* maestro

Quanto sopra ti dice che esiste un solo ramo chiamato "master" e l'asterisco (*) significa che sei su quel ramo.

Creiamo un nuovo ramo chiamato 'testing':

$git branch test

Ora possiamo controllare di nuovo i rami:

$git branch -a
* maestro
test

Anche se siamo ancora sul ramo 'master', possiamo anche vedere il nuovo ramo 'testing' che è stato creato. Il ramo "testing" è una replica del ramo "master".

3. git checkout

Il comando git checkout ti porta in un ramo, così puoi lavorare sulle risorse lì dentro. Puoi pensare ai rami come fiumi e ruscelli. Con un ramo crei un nuovo stream. Con il comando checkout, ti sposti in quel flusso.

Esaminiamo il ramo 'testing' dell'esempio precedente:

$git checkout test
Passato al ramo 'test'

Ora controlliamo di nuovo lo stato e i rami:

$git status
Test in filiale
niente da eseguire, pulizia della directory di lavoro
$git ramo -a
maestro
* test

Puoi vedere dal comando git branch -a che abbiamo spostato nel ramo testing.

4. git clone

Il comando git clone ti permette di fare una copia di qualsiasi repository Git. Non appena cloni un repository, la nuova cartella clonata inizierà a tenere traccia delle modifiche localmente. 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 mioprogetto
$cd mioprogetto/
$git init
Repository Git vuoto inizializzato in /dir1/myproject/.idiota/
$touch Leggimi.TXT
$git commit -m 'Inizializza il mio repository'
[master (root-commit) 5a0bd75] Inizializza il mio repository
1 file modificato, 0 inserimenti(+), 0 eliminazioni(-)
crea modalità 100644 Leggimi.TXT

Nell'esempio sopra, abbiamo creato un repository Git chiamato 'myproject' all'interno della cartella 'dir1'. Supponiamo che questo sia il nostro repository principale. Ora vogliamo farne una copia e lavorare altrove.

Creiamo una directory chiamata 'dir2' e cloniamo il repository 'myproject'. Stiamo usando il clone git

per clonare 'mioprogetto':

$mkdir dir2
$cd dir2
$git clone /dir1/mioprogetto/
Clonazione in 'myproject'..
fatto.
$ls
il mio progetto

Il comando git clone funziona anche con un URL.

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

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

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

5. git commit

Il comando git commit viene eseguito dopo il comando git add. Nel nostro esempio git add, abbiamo aggiunto i file per il monitoraggio, ma non li abbiamo inseriti nel repository Git. Il monitoraggio rimane locale fino a quando non viene effettuato un commit. Quando effettui il commit delle modifiche, queste diventano parte del record permanente.

Di seguito stiamo eseguendo il git commit -m comando:

$git commit -m 'Commit i miei file e cartelle'
[master 3ef57b3] Commettere i miei file e cartelle
4 file modificati, 0 inserimenti(+), 0 eliminazioni(-)
crea modalità 100644 file1.TXT
crea modalità 100644 file2.TXT
modalità di creazione 100644 cartella1/file3.TXT
crea modalità 100644 cartella1/file4.TXT

Se non usi l'opzione -m per inserire 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 inserisci sempre commenti significativi nel tuo commit.

6. git config

Il comando git config ti consente di impostare varie opzioni per il tuo repository git. Ad esempio, puoi usare git config -global comando per ottenere e impostare il tuo utente.nome e utente.e-mail.

Ecco come impostare i valori:

$ git config --utente globale.nome 'Zak H'
$ git config --utente globale.email [email protected]

Ecco come puoi controllare i valori:

$git config --utente globale.nome
Zak H
$git config --utente globale.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 a un file, è uno strumento utile per valutare rapidamente le modifiche apportate.

Supponiamo di iniziare il nostro lavoro con un ReadMe.txt con due righe. Quindi eliminiamo la seconda riga e aggiungiamo una terza riga.

Ora se eseguiamo il comando diff mostrerà le differenze tra la versione confermata e la versione modificata locale nell'area di staging sta. Ecco come apparirà:

$git diff
diff --git a/ReadMe.txt b/Leggimi.TXT
indice 9475ddc… 1804904 100644
--- a/Leggimi.TXT
+++ b/Leggimi.TXT
@@ -1,2 +1,2 @@
Riga 1: La mia prima riga
-Riga 2: La mia seconda riga
+Riga 3: La mia TERZA riga

La riga 1 è invariata (bianca), la riga 2 rimossa (rossa) e la riga 3 aggiunta (verde).
Puoi usare il comando diff anche per trovare differenze tra commit particolari.

8. git fetch

Il comando git fetch ottiene le ultime risorse dall'origine specificata.

Facciamo un esempio. Supponiamo che tu abbia la seguente condizione:

dir1/mioprogetto
dir2/mioprogetto (clonato)

La cartella 'dir2/myproject' viene clonata da 'dir1/myproject'. Ora, se qualcuno ha apportato modifiche a "dir1/myproject", puoi ottenere tali modifiche in questo modo dall'interno di "dir2/myproject":

$git recupera origine
remoto: Conteggio oggetti: 2, fatto.
remoto: Compressione di oggetti: 100% (2/2), fatto.
remoto: Totale 2 (delta 0), riutilizzato 0 (delta 0)
Disimballaggio degli oggetti: 100% (2/2), fatto.
Da /dir2/… /dir1/mioprogetto
5a0bd75… 1713734 master -> origine/master

È importante ricordare che il comando git fetch non unisce le modifiche. Per il recupero e l'unione automatici, usa il comando git pull. Allora ti starai chiedendo perché usare questo comando in primo luogo. Potrebbero esserci opzioni Git avanzate in cui ottieni tutte le modifiche dal tuo server di origine e quindi applichi le modifiche solo in modo selettivo a determinati file. Il comando git fetch ti consente di ottenere questo. Tuttavia, è un argomento avanzato che puoi trovare nella documentazione di git fetch.

9. git grep

Il comando git grep ti consente di cercare informazioni nel tuo albero Git. Ecco un esempio di ricerca della parola "Linea" nel nostro repository git. L'opzione -n o --line-number mostra i numeri di riga in cui Git trova una corrispondenza:

$git grep -n Riga
Leggimi.txt:1:Linea 1: La mia prima linea
Leggimi.txt:2:Riga 3: La mia TERZA riga

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

git grep -c Riga
Leggimi.txt: 2

Il motivo per cui si usa git grep su Linux grep è che git grep è più veloce per i repository git.

10. git log

Il comando git log ti mostra la cronologia dei 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 usare 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 merge

Il comando git merge unisce i rami.

Creiamo un nuovo repository con 'main' e poi creiamo un ramo 'test'.

$mkdir mioprogetto
$cd mioprogetto
$git init
Repository Git vuoto inizializzato in /git_essentials/myproject/.idiota/
$touch Leggimi.TXT
$git add -A
$git commit -m 'Commit iniziale'
[master (root-commit) b31d4e1] commit iniziale
1 file modificato, 0 inserimenti(+), 0 eliminazioni(-)
crea modalità 100644 Leggimi.TXT
$git branch test
$git branch -a
* maestro
test
$git checkout test
Passato al ramo 'test'

Nel ramo 'test', apportiamo alcune modifiche:

$tocca File1.txt File2.TXT
$Ls
File1.txt File2.txt Leggimi.TXT
$git add -A
$git commit -m 'Aggiunto due nuovi file'
[test 7e11910] Aggiunti due nuovi file
2 file modificati, 0 inserimenti(+), 0 eliminazioni(-)
modalità di creazione 100644 File1.TXT
modalità di creazione 100644 File2.TXT

Abbiamo aggiunto due file al test.

$git branch -a
maestro
* prova
$ls
File1.txt File2.txt Leggimi.TXT
$git checkout master
Passato al ramo 'master'
$git branch -a
* maestro
test
$ls
Leggimi.TXT

Vediamo da quanto sopra, che File1.txt e File2.txt esiste nel ramo 'test', ma non in 'master'.

Uniamoci ora.

$git test di unione
Aggiornamento b31d4e1… 7e11910
Avanti veloce
File1.txt | 0
File2.txt | 0
2 file modificati, 0 inserimenti(+), 0 eliminazioni(-)
modalità di creazione 100644 File1.TXT
modalità di creazione 100644 File2.TXT
$ls
File1.txt File2.txt Leggimi.TXT
$git branch -a
* maestro
test

Ora abbiamo "File1".txt' e 'File2.txt' anche nel ramo 'master'.

Nota: considera l'unione come un'operazione di pull. Devi essere nel ramo in cui vuoi unirti. In questo caso, sei nel ramo 'master' estraendo le modifiche dal ramo 'test'.

12. git mv

Il git mv è un comando di scorciatoia per eseguire i comandi git add e git rm. Può essere usato per rinominare i file.

Ecco un esempio:

$git mv Leggimi.txt Leggimi.md
$git stato
Sul maestro di filiale
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
rinominato: Leggimi.txt -> Leggimi.md

13. git pull

Il comando git pull è molto simile a git fetch, tranne che l'unione avviene automaticamente.

Ecco un esempio di esecuzione di git pull origin come git fetch one (stiamo eseguendo una richiesta pull dal clone per ottenere modifiche dal repository Git originale):

$git pull origin
remoto: Conteggio oggetti: 3, fatto.
remoto: Compressione di oggetti: 100% (2/2), fatto.
remoto: Totale 3 (delta 0), riutilizzato 0 (delta 0)
Disimballaggio degli 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 +
Leggimi.txt => Leggimi.md | 0
4 file modificati, 3 inserimenti(+)
modalità di creazione 100644 File3.TXT
rinomina Leggimi.txt => Leggimi.md (100%)

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

14. git push

Il comando git push viene utilizzato per inviare modifiche ai repository remoti. Ecco un esempio di esecuzione del comando push:

$git push origine master
Conteggio oggetti: 2, fatto.
Compressione delta utilizzando fino a 4 thread.
Comprimere oggetti: 100% (2/2), fatto.
Oggetti in scrittura: 100% (2/2), 242 byte | 0 byte/s, fatto.
Totale 2 (delta 1), riutilizzato 0 (delta 0)
A /LearnGIT/git_essentials/myproject
e67f932… 90dc546 master -> master

Il comando git push origin master sta inviando modifiche al ramo "master" dell'origine (il repository Git che hai clonato) dal ramo "master" del repository clonato. Visivamente, la spinta si presenta così:

clonato/master -> origine/master

15. git rebase

Il comando git rebase ti aiuta a cambiare la base dei rami. In un'unione generale, accade qualcosa del genere:

Il ramo di test è stato unito al ramo 'master' per creare un nuovo commit.

In un rebase, questo è ciò che accade:

Le modifiche dall'elenco modifiche E e F vengono ricalcolate e memorizzate alla fine del ramo principale. Il rebasing aiuta a semplificare le filiali.

Supponiamo di avere 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 rebase, otteniamo git rebase master:

$ funzione di pagamento git
Passato alla "funzionalità" del ramo
$ git rebase master

Per prima cosa, riavvolgi la testa per riprodurre il tuo lavoro su di essa..

Applicazione: Commit E: modificato a.TXT
Applicazione: Commit F: modificato b.TXT
Quindi unisci 'feature' in 'master'.
$ git checkout master
Passato al ramo 'master'
$ git funzione di unione
Aggiornamento 7f573d8… 9efa1a3
Avanti veloce
un.txt | 1 +
b.txt | 1 +
2 file modificati, 2 inserimenti(+)

Ora se vai al ramo 'master' e 'feature', vedrai gli stessi log:

$ 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 utilizzare mai il rebase nei repository pubblici poiché gli sviluppatori incorreranno in importanti problemi di unione.

16. git remote

Il comando git remote ti permette di impostare un server remoto per il tuo repository. In una situazione di clonazione, il repository di origine diventa automaticamente il remoto.

Per esempio:

$pwd
/LearnGIT/git_essentials/test
$git remote -v
origine /LearnGIT/git_essentials/myproject (recupero)
origine /LearnGIT/git_essentials/myproject (push)

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

Ma il server remoto non ha bisogno di essere locale. Puoi avere qualcosa del genere con un URL:

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

Puoi configurare un repository remoto git usando il comando git remote add :

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

Questo collegherà il tuo repository all'origine in modo che tu possa recuperare e spingere.

17. git reset

Il ripristino di git ti consente di annullare lo stage dei file aggiunti.

Diciamo che hai aggiunto il file 'test.txt' nel tuo repository:

$test di tocco.TXT
$git add -A
$git stato
Sul maestro di filiale
La tua filiale è aggiornata con 'origine/master'.
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
nuovo file: test.TXT

Tuttavia, decidi di non voler monitorare il "test".txt' più. Puoi usare git reset Head comando per annullare lo stage del file:

$git resetta il test HEAD.TXT

Se controlli lo stato, il file non viene nuovamente tracciato:

$git stato
Sul maestro di filiale
La tua filiale è aggiornata con 'origine/master'.
File non tracciati:
(usa 'git add …' da includere in ciò che sarà impegnato)
test.TXT

Il file "prova".txt' non viene più tracciato.

18. git ripristinare

Il comando git revert ti consente di invertire le modifiche usando il numero hash di commit.

$echo 'Test 1' >> MioFile.TXT
$git add -A
$git commit -m 'Modifica aggiunta 1'
[master 78a8277] Aggiunto il cambiamento 1 Change
2 file modificati, 1 inserimento(+)
modalità di creazione 100644 MyFile.TXT
crea modalità 100644 prova.TXT
$cat MyFile.TXT
Prova 1
$echo 'Test 2' >> MioFile.TXT
$git add -A
$git commit -m 'Modifica aggiunta 2'
[master a976e9c] Aggiunto il cambiamento 2
1 file modificato, 1 inserimento(+)
$cat MyFile.TXT
Prova 1
Prova 2
$git log --oneline
a976e9c Modifica aggiunta 2
78a8277 Aggiunto Modifica 1
90dc546 Aggiunto un file
e67f932 Aggiunti nuovi file
7e11910 Aggiunti due nuovi file
b31d4e1 Commessa iniziale

Abbiamo creato un "MyFile".txt" e ha eseguito il commit di 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 l'hash di commit (a976e9c) per esso. Possiamo usare git revert per sbarazzarsi del commit:

$git ripristina a976e9c
[master 4f270e7] Ripristina 'Modifica aggiunta 2'
1 file modificato, 1 cancellazione (-)
$git log --oneline
4f270e7 Ripristina "Modifica aggiunta 2"
a976e9c Modifica aggiunta 2
78a8277 Modifica aggiunta 1
90dc546 Aggiunto un file
e67f932 Aggiunti nuovi file
7e11910 Aggiunti due nuovi file
b31d4e1 Commessa iniziale
$cat MyFile.TXT
Prova 1

Vediamo che è stato creato un nuovo hash di commit che ha ripristinato il commit della riga "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 da eliminare nell'area di staging.

$git rm test.TXT
rm 'test.TXT'
$git stato
Sul maestro di filiale
Il tuo ramo è davanti a "origine/master" di 3 commit.
(usa 'git push' per pubblicare i tuoi commit locali)
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
cancellato: test.TXT

Devi confermare le modifiche affinché l'eliminazione abbia effetto.

20. git stash

Il comando git stash ti consente di abbandonare temporaneamente il lavoro che non sei ancora pronto a impegnare.
Supponiamo di lavorare in un repository con i seguenti file:

$ls
John.txt   Maria.TXT
Vuoi modificare questi file in modo che siano più basati sul progetto. Quindi inizi con:
$git mv John.txt ProjectFile1.TXT
$ls
Maria.txt       ProjectFile1.TXT
$git stato
Sul maestro di filiale
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
rinominato:    John.txt -> ProjectFile1.TXT

Nel mezzo della ridenominazione e dell'aggiornamento di "John".txt' in 'FileProgetto1.txt', ricevi una richiesta per modificare qualcosa nel progetto. Ma non sei pronto per inviare "ProjectFile1".TXT'. Quindi lo nascondi.

$git stash

Directory di lavoro salvata e stato dell'indice WIP sul master: f0b5a01 Init John e Mary

HEAD è ora su f0b5a01 Init John e Mary

$ls
John.txt Maria.TXT

Il tuo ambiente di lavoro locale è tornato al punto in cui eri prima di apportare le modifiche basate sul progetto. Dopo, occupandosi dell'interruzione, invece di tornare a 'John'.txt', decidi di lavorare su 'Mary.txt' ora:

$git mv Mary.txt ProjectFile2.TXT
$git stato
Sul maestro di filiale
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
ribattezzato: Mary.txt -> ProjectFile2.TXT
$ls
John.txt ProjectFile2.TXT

Vieni interrotto di nuovo e nascondi il tuo nuovo lavoro su "Mary".TXT':

$git stash
Directory di lavoro salvata e stato dell'indice WIP sul master: f0b5a01 Init John e Mary
HEAD è ora su f0b5a01 Init John e Mary
$ls
John.txt Maria.TXT

Dopo che il lavoro di interruzione è terminato, controlli l'elenco delle scorte:

$git stash list
stash@0: WIP sul master: f0b5a01 Init John e Mary
stash@1: WIP sul master: f0b5a01 Init John e Mary

Hai due lavori in corso (WIP) nella scorta in. La prima volta che apri la scorta, ricevi l'ultimo "Mary".txt' cambia:

$git stash pop
Rimozione di Mary.TXT
Sul maestro di filiale
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
nuovo file: ProjectFile2.TXT
Modifiche non programmate per il commit:
(usa 'git add/rm …' per aggiornare ciò che sarà impegnato)
(usa 'git checkout' -- … 'per annullare le modifiche nella directory di lavoro)
cancellato: Mary.TXT
Rifiuti/stash eliminati@0 (9b77a6b75e4e414fb64de341668c812d3d35150c)

La seconda volta che apri la scorta, ottieni il "John".modifiche relative a txt':

$git stash pop
Rimozione di John.TXT
Sul maestro di filiale
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
nuovo file:   ProjectFile1.TXT
nuovo file:   ProjectFile2.TXT
Modifiche non pianificate per il commit:
(usa 'git add/rm …' per aggiornare ciò che sarà impegnato)
(usa 'git checkout' -- … 'per annullare le modifiche nella directory di lavoro)
cancellato:    John.TXT
cancellato:    Mary.TXT
Riferimenti/stash eliminati@0 (1e1968854fb5ca4d609e577822dc3280dbf928f6)
$ls
FileProgetto1.txt   ProjectFile2.TXT

E hai il tuo lavoro in corso "ProjectFile1".txt' e 'FileProgetto2.txt' indietro.

Quindi il comando git stash ti aiuta a riporre il tuo lavoro in modo da poterci tornare più tardi.

21. stato git

Il comando git status mostra la differenza tra i file correnti e il commit HEAD.

Ecco un esempio:

$git stato
Sul maestro di filiale
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
rinominato: File2.txt -> File3.TXT
Modifiche non programmate per il commit:
(usa 'git add …' per aggiornare ciò che sarà impegnato)
(usa 'git checkout' -- … 'per annullare le modifiche nella directory di lavoro)
modificato: File1.TXT

Sta mostrando che "File2".txt' viene rinominato in 'File3.txt' che è pronto per il commit, ma le modifiche in 'File1.txt' non è ancora nell'area di staging.

Quindi, aggiungiamo tutto:

$git add -A

Ora, quando controlliamo lo stato:

$git stato
Sul maestro di filiale
Modifiche da commettere:
(usa 'git reset HEAD' …' disin scena)
modificato: File1.TXT
rinominato: File2.txt -> File3.TXT

Vediamo che tutte le modifiche sono pronte per il commit.

22. git tag

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

Il comando git tag ti mostrerà i tag attualmente disponibili:

$git tag
v1.0
v2.0

Puoi taggare con il formato di comando git tag :

$git tag v3.0

Per vedere cosa c'è nel tag, puoi usare il comando git show:

$git mostra v1.0
commit 61e9e8aa1b98b2a657303e6822b291d2374314b5
Autore: Zak H
Data: Gio Nov 22 01:06:42 2018 -0800
Primo impegno
diff --git a/1.txt b/1.TXT
nuova modalità file 100644
indice 0000000… e69de29

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

$git log --oneline
374efe9 File modificato
a621765 Aggiungi
6d6ed84 Secondo commit
61e9e8a Primo commit
$git tag v4.0 a621765
$git mostra v4.0
commit a6217650a2c7b2531ecb9c173ba94bd4b3ba7abd
Autore: Zak H
Data: Gio Nov 22 01:15:55 2018 -0800
Inserisci
diff --git a/1.txt b/1.TXT
indice e69de29… 587be6b 100644
--- a/1.TXT
+++ b/1.TXT
@@ -0,0 +1 @@

In conclusione

Per qualsiasi comando, puoi usare git -h per avere maggiori informazioni.

Ulteriori studi

https://git-scm.com/docs