Stai controllando un vecchio commit e mantenendo la testa sul ramo master?

Attualmente per passare a un altro commit git (sullo stesso ramo ... in realtà, sul ramo master!), Sto eseguendo il comando

git checkout ea3d5ed039edd6d4a07cc41bd09eb58edd1f2b3a

Ora, ogni volta che lo faccio git mi dice che ora sono con una testa distaccata. Come posso passare a un commit più vecchio e mantenere comunque la testa sullo stesso ramo?

Il più delle volte quando lo faccio, eseguo il checkout in un ramo temporaneo:

git checkout -b temp-branch-name ea3d5ed039edd6d4a07cc41bd09eb58edd1f2b3a

Quindi, dopo aver finito, elimino semplicemente il ramo

Dipende da cosa vuoi fare quando effettui il checkout di quel commit. Se tutto ciò che stai facendo è verificarlo in modo da poter costruire o testare quella revisione, allora non c'è niente di sbagliato nel lavorare con una testa staccata. Ricorda solo di controllare un ramo effettivo prima di effettuare qualsiasi commit ( git checkout master, ad esempio), in modo da non creare commit che non siano inclusi in alcun ramo.

Se, invece, vuoi fare più commit a partire da quel punto, dovresti creare un branch. Se effettui commit che non sono referenziati da un ramo, possono perdersi facilmente e alla fine verranno ripuliti dal garbage collector di git, poiché nulla si riferisce a loro. Puoi creare un nuovo ramo eseguendo:

git checkout -b newbranch ea3d5ed

Per aiutare a visualizzare, ecco alcuni diagrammi che dimostrano come lavorare su una testa staccata differisce dal lavorare su un ramo.

Iniziamo con 3 commit su master, A, B e C. masterè il ramo corrente, quindi HEADpunta a master, che punta a commit C.

ABC
* - * - * <- master <- HEAD

Ora, se eseguiamo il commit, git creerà un commit che ha C come genitore (perché è il commit corrente, puntato da HEADvia master), e si aggiornerà masterper puntare a quel nuovo commit. Tutti i nostri commit sono ora in mastere HEADpunta al nuovo commit master.

ABCD
* - * - * - * <- master <- HEAD

Adesso controlliamo B, dandoci un distaccato HEAD.

ABCD
* - * - * - * <- master
   ^
    \-- CAPO

Tutto funziona bene qui; possiamo guardare tutti i file, costruire il nostro programma, testarlo, ecc. Possiamo anche creare nuovi commit; ma se lo facciamo, non c'è nessun ramo su cui siamo, quindi non possiamo puntare nessun ramo a quel nuovo commit. L'unica cosa che lo indica è HEAD:

ABCD
* - * - * - * <- master
    \
     * <- TESTA
     E

Se in seguito decidiamo di effettuare masternuovamente il check-out , non ci sarà nulla che si riferisca a E.

ABCD
* - * - * - * <- master <- HEAD
    \
     *
     E

Dal momento che non c'è nulla che si riferisca ad esso, può essere difficile da trovare e git considera i commit senza riferimenti da abbandonare (accadono abbastanza comunemente se si rebase, si squash patch o si fanno altre manipolazioni della cronologia divertenti; di solito rappresentano patch abbandonate che non ti interessa più). Dopo un certo periodo di tempo, git lo considererà spazzatura, da scartare la prossima volta che viene eseguito il garbage collection.

Quindi, invece di controllare una semplice revisione e ottenere una testa distaccata, se hai la sensazione di fare più commit, dovresti usare git checkout -b branch Bper creare un ramo e controllarlo. Ora i tuoi commit non andranno persi, poiché saranno inclusi in un ramo, a cui puoi facilmente fare riferimento e unire in seguito.

ABCD
* - * - * - * <- master
   ^
    \ - ramo <- TESTA

Se ti dimentichi di farlo e crei commit da un ramo, non devi preoccuparti. È possibile creare un ramo che fa riferimento alla revisione della testina con git checkout -b branch. Se sei già tornato al masterramo e ti rendi conto di aver dimenticato un commit vagante, puoi trovarlo usando git reflog, che ti mostrerà una cronologia di ciò a cui i commit HEADhanno puntato negli ultimi giorni. Tutto ciò che è ancora nel reflog non verrà raccolto nella spazzatura e generalmente i riferimenti vengono conservati nel reflog per almeno 30 giorni.

Se vuoi semplicemente tornare a un commit precedente per giocarci senza apportare modifiche, puoi farlo

git co <previous-commit-id>

ti troverai su un ramo chiamato "(nessun ramo)" dopo questo comando.

Confermalo da

git br

Dopo aver giocato con questo codice precedentemente impegnato, puoi passare al ramo in cui ti trovavi

git co <the-branch-you-were-on>

Il "(nessun ramo)" verrà eliminato automaticamente. In questo modo non è necessario creare un ramo temporaneo.

Git's HEAD è semplicemente un puntatore che dice cosa c'è nella directory di lavoro. Se vuoi controllare un commit che non è il capo di un ramo, devi semplicemente reindirizzare il tuo HEAD in modo che punti a quel commit. Non c'è modo di aggirarlo. Puoi creare un ramo temporaneo in quel commit, ma HEAD sarà comunque diretto lontano dal master.

Questa è la breve spiegazione. Si spera che il livello di dettaglio di seguito aiuti a capire in che modo HEAD e master sono diversi:

Normalmente, le cose assomigliano a questo:

C ← refs/heads/master ← HEAD 
↓
B
↓
A

Vale a dire: “Il genitore di C è B, e il genitore di B è A. Il branch master punta a C, e attualmente ho controllato il contenuto di master. Inoltre, quando mi impegno, il master verrà aggiornato. "

Alcune ipotesi sono implicite in questo che sono necessarie per una comprensione completa del grafo di commit. Vale a dire, i commit si riferiscono solo ai loro genitori, e il contenuto di un branch sono quei commit (e solo quei commit) che possono essere raggiunti seguendo i link genitore. Il contenuto (non modificato) dell'albero di lavoro e dell'indice devono corrispondere al commit denominato da HEAD, indirettamente ("simbolico") o direttamente ("scollegato").

Pertanto, se si desidera eseguire il check out di un vecchio commit, è necessario aggiornare HEAD in modo che punti al commit desiderato. git-checkoutfa proprio questo:

C ← refs/heads/master 
↓
B ← HEAD
↓
A

Ora, hai lasciato il tuo ramo dietro di te, dato che stai guardando qualcosa di vecchio. Va benissimo, come ti dice con calma il consiglio della "testa distaccata" (enfasi mia):

Puoi guardarti intorno, apportare modifiche sperimentali e eseguirne il commit e puoi annullare qualsiasi commit effettuato in questo stato senza influire sui rami eseguendo un altro checkout.

D'altra parte, mentre resettando il tuo ramo ottieni anche HEAD dove deve essere, avrebbe un effetto molto diverso!

C
↓
B ← refs/heads/master ← HEAD
↓
A

Il commit C diventerà spazzatura, poiché hai dichiarato che non desideri più che faccia parte del ramo master.

In breve, tutto ciò che devi fare è capire cosa significa git per "HEAD" - è dove sei , non dove si trova un determinato ramo. E se dove sei non è uguale a dove si trova un ramo, non c'è altra scelta che usare una TESTA staccata.

(Forse guarda anche GitHub, gitk o gitweb per sfogliare la cronologia dei commit, se il deragliamento di HEAD continua a infastidirti.)

La domanda è un po 'vaga, ma se vuoi semplicemente cambiare i file nel tuo albero di lavoro, puoi semplicemente farlo:

git checkout [commit|branch] -- .

Puoi quindi mettere in scena le modifiche e creare un nuovo commit se lo desideri. Questo è abbastanza utile a volte.

Penso di aver capito le tue domande. Ecco cosa ho trovato per risolverlo. e non esiste una soluzione GUI, puoi solo usare il comando per risolverlo, ed è davvero semplice.

passaggio 1: crea un tag del vecchio commit che desideri ripristinare.

come tag v2.0

passaggio 2: git checkout v2.0

eccolo, ora il tuo HEAD punta al commit 'v2.0', ma il master punta ancora all'ultimo commit.

C:\Program Files\Git\doc\git\html\git-checkout.html questo documento può aiutarti

oppure digita git help <checkout>