Come tornare alla versione più recente di Git?


303

Di recente sono passato da SVN a Git e sono un po 'confuso per qualcosa. Avevo bisogno di eseguire la versione precedente di uno script tramite un debugger, quindi ho fatto git checkout <previous version hash>e fatto quello che dovevo fare.

Ora voglio tornare alla versione più recente, ma non conosco l'hash per questo. Quando scrivo git log, non lo vedo.

Come posso fare questo? Inoltre, c'è un modo più semplice per cambiare versione che digitando gli hash - qualcosa come "torna indietro di due versioni" o "vai al più cronologicamente recente"?

Risposte:


371

git checkout masterdovrebbe fare il trucco. Per tornare indietro di due versioni, potresti dire qualcosa del genere git checkout HEAD~2, ma è meglio creare un ramo temporaneo basato su quel tempo, quindigit checkout -b temp_branch HEAD~2


7
Freddo! git checkout masterè esattamente come torno da un ramo. Ciò significa che quando controllo una versione precedente, sto essenzialmente creando un ramo?
Nathan Long,

4
@Nathan: In git un ramo è in realtà principalmente un puntatore mobile a una certa revisione. Quindi concettualmente, stai creando una specie di ramo, ma non nel senso che Git pensa ai rami.
DLH

2
Quindi, nel caso più semplice, dove ho un sacco di cambiamenti lineari, quando controllo una revisione precedente, sto spostando lì il puntatore HEAD, il che significa che git logverrà visualizzato relativamente a quel punto? E quando eseguo il checkout del master, sposto il puntatore sull'ultima versione del ramo master?
Nathan Long,

7
@Nathan: esattamente. HEAD è qualcosa chiamato ref simbolico - in generale è un puntatore a un altro ref (il ramo attualmente estratto). git checkoutè un modo per spostare HEAD. Quando hai rimosso HEAD, hai indicato direttamente quel determinato commit; quando si verifica di nuovo il master, questo indica di nuovo il master. (E molti altri comandi come in git logrealtà prendono un intervallo di revisione, che per impostazione predefinita è HEAD.)
Cascabel

3
Sì - HEAD è il "pronome" utilizzato per fare riferimento a "La versione del codice che si trova nella directory di lavoro". È anche il pronome di "Il genitore di qualunque cosa tu commetta dopo"
Ana Betts,

54

Quando esegui il checkout per un commit specifico, git crea un ramo distaccato. Quindi, se chiami:

$ git branch 

Vedrai qualcosa come:

* (detached from 3i4j25)
  master
  other_branch

Per tornare alla testa del ramo principale, devi solo effettuare nuovamente il checkout al ramo principale:

$ git checkout master

Questo comando eliminerà automaticamente il ramo staccato.

Se git checkoutnon funziona, probabilmente hai modificato i file in conflitto tra i rami. Per evitare di perdere il codice git richiede di gestire questi file. Hai tre opzioni:

  1. Riponi le modifiche (puoi aprirle in seguito):

    $ git stash
    
  2. Annulla le modifiche ripristinando il ramo distaccato:

    $ git reset --hard
    
  3. Crea un nuovo ramo con le modifiche precedenti e impegnale:

    $ git checkout -b my_new_branch
    $ git add my_file.ext
    $ git commit -m "My cool msg"
    

Dopodiché puoi tornare al tuo ramo principale (versione più recente):

$ git checkout master

36

Questo ha fatto il trucco per me (ero ancora nel ramo principale):

git reset --hard origin/master

34
reset --hard è eccessivo e dimostra che non sei a conoscenza delle modifiche apportate. Ciò può comportare la perdita del codice.
Thomio

1
Nel mio caso, volevo sbarazzarmi delle modifiche involontariamente commesse non elaborate. So che ci possono essere altri metodi per raggiungere questo obiettivo. Sono d'accordo che se non vuoi perdere le modifiche impegnate non elaborate, si tratta della perdita di dati.
Csaba Toth,

8

Per tornare all'ultima versione:

git checkout <branch-name> 

Ad esempio, git checkout masteroppuregit checkout dev


7

Puoi controllare usando i nomi delle filiali, per prima cosa.

So che ci sono molti modi per spostare HEAD, ma lo lascerò a un esperto git per elencarli.

Volevo solo suggerire gitk --all- l'ho trovato estremamente utile quando ho iniziato con Git.


7

Sto solo cominciando a scavare più in profondità git, quindi non so se ho capito bene, ma penso che la risposta corretta alla domanda del PO è che è possibile eseguire git log --allcon una specifica di formato come questo: git log --all --pretty=format:'%h: %s %d'. Questo contrassegna la versione attualmente estratta come (HEAD)e puoi semplicemente afferrare la successiva dall'elenco.

A proposito, aggiungi un alias come questo al tuo .gitconfigcon un formato leggermente migliore e puoi eseguire git hist --all:

  hist = log --pretty=format:\"%h %ai | %s%d [%an]\" --graph

Per quanto riguarda le versioni relative, ho trovato questo post , ma parla solo di versioni precedenti, probabilmente non c'è nulla da fare riferimento alle versioni più recenti.


6

Alcune delle risposte qui presuppongono che tu sia nel ramo principale prima di decidere di effettuare il checkout di un commit precedente. Questo non è sempre il caso.

git checkout -

Ti riporterà al ramo in cui eri in precedenza (indipendentemente dal fatto che fosse master o meno).


Non è necessario un ramo, punterà HEAD a dove puntava prima; se lo hai fatto git checkout hash2dopo git checkout hash1, git checkout -ti riporterà a hash1.
Mikhail Vasin,

3

Quando torni a una versione precedente,

$ git checkout HEAD~2
Previous HEAD position was 363a8d7... Fixed a bug #32

Puoi vedere il tuo registro delle funzioni (hash) con questo comando anche in questa situazione;

$ git log master --oneline -5
4b5f9c2 Fixed a bug #34
9820632 Fixed a bug #33
...

master può essere sostituito con un altro nome di filiale.

Quindi dai un'occhiata, sarai in grado di tornare alla funzione.

$ git checkout 4b5f9c2
HEAD is now at 4b5f9c2... Fixed a bug #34

1

Con Git 2.23+ (agosto 2019), la migliore pratica sarebbe usare al git switchposto del comando confusogit checkout .

Per creare un nuovo ramo basato su una versione precedente:

git switch -c temp_branch HEAD~2

Per tornare al ramo master corrente:

git switch master

0

Una soluzione più elegante e semplice è quella di utilizzare

git stash

Tornerà alla versione locale del ramo più rinviata e salverà anche le modifiche nello stash, quindi se ti piace annullare questa azione fai:

git stash apply

So che è molto vecchio, ma devo fare un commento su questo (dal momento che penso che questa soluzione non dovrebbe essere utilizzata) - Non userei questa soluzione perché non risolve questo problema ma un problema diverso. con questa soluzione stash ogni volta che si desidera effettuare il checkout a un commit precedente, in realtà si "salvano" i dati che non sono molto necessari in questo caso. Il modo giusto ed elegante è (come affermato in precedenza) di effettuare il checkout <branch>.
Maayao,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.