Come posso andare avanti e indietro tra i commit in git?

Sto facendo un git bisecte dopo essere arrivato al commit problematico, ora sto cercando di fare un passo avanti / indietro per assicurarmi di essere in quello giusto.

So di HEAD^tornare indietro nella storia, ma c'è un'altra scorciatoia per farmi andare avanti (verso un impegno specifico in futuro) in questo modo:

A - B - C(HEAD) - D - E - F

So che il mio obiettivo è F e voglio passare da C a D .

NOTA: questo non è un duplicato di Git: come spostarsi avanti e indietro tra i commit , la mia domanda è leggermente diversa e non trova risposta lì

Ho sperimentato un po 'e questo sembra fare il trucco per navigare in avanti ( modifica : funziona bene solo quando hai una cronologia lineare senza merge commit):

git checkout $(git rev-list --topo-order HEAD..towards | tail -1)

dove towardsè uno SHA1 del commit o un tag.

Spiegazione:

• il comando all'interno $()significa: ottieni tutti i commit tra current HEADe towardscommit (escluso HEAD), e ordinali nell'ordine di precedenza (come git logper impostazione predefinita - invece dell'ordine cronologico che è stranamente l'impostazione predefinita per rev-list), quindi prendi l'ultimo ( tail), ovvero quello a cui vogliamo andare.
• questo viene valutato nella subshell e passato a git checkoutper eseguire un checkout.

È possibile definire una funzione accessibile come alias in attesa di parametri nel .profilefile per navigare in avanti verso il commit specifico:

# Go forward in Git commit hierarchy, towards particular commit 
# Usage:
#  gofwd v1.2.7
# Does nothing when the parameter is not specified.
gofwd() {
  git checkout $(git rev-list --topo-order HEAD.."$*" | tail -1)
}

# Go back in Git commit hierarchy
# Usage: 
#  goback
alias goback='git checkout HEAD~'

Tutto ciò di cui hai bisogno per ottenere uno stato principale chiaro, non scollegato è ripristinare, non effettuare il checkout.

git reset HEAD@{1}

Credo che tu possa fare:

git reset HEAD@{1}

Per andare avanti nel tempo. Per andare avanti con più commit, utilizza HEAD @ {2}, HEAD @ {3} e così via.

Questo è ciò che sto usando per navigare avanti e indietro.

passare al commit successivo

function n() {
    git log --reverse --pretty=%H master | grep -A 1 $(git rev-parse HEAD) | tail -n1 | xargs git checkout
}

passaggio al commit precedente

function p() {
    git checkout HEAD^1
}

Diciamo che F è l'ultimo commit su trunk(inserisci il tuo nome di ramo qui) ... puoi riferirti ad esso come trunk~0(o semplicemente trunk), E come trunk~1, D come trunk~2ecc.

Dai un'occhiata nel tuo reflog per ulteriori modi per nominare i commit.

Attraversare all'indietro è banale poiché ti stai spostando giù dall'albero e c'è sempre una strada da percorrere

  function git_down
        git checkout HEAD^
  end

Quando si procede in avanti, si sta risalendo l'albero, quindi è necessario essere espliciti su quale ramo si sta mirando:

  function git_up 
        git log --reverse --pretty=%H $argv | grep -A 1 (git rev-parse HEAD) | tail -n1 | xargs git checkout
  end

Uso: git down,git up <branch-name>

Se vuoi vedere avanti, puoi fare questo trucco, poiché Git non ha un comando rigoroso per questo.

git log --reverse COMMIT_HASH..

Esempio

Elenco degli hash della cronologia dei log:

A
B
C -> put this
D

utilizzando il comando git log --reverse C.., in uscita si vedrà B e A .

Probabilmente non è il modo più carino, ma puoi utilizzare git logper visualizzare l'elenco dei commit e quindi utilizzare git checkout [sha1 of D]per passare a D.

Ho appena fatto un test su questo. dì per esempio che sei nel ramo principale Quindi fai:

git checkout HEAD@{3}

Quindi la testa si stacca e puoi quindi riprovare per passare a qualsiasi altro commit:

git checkout HEAD@{4}

Una volta che hai finito di guardarti intorno, puoi tornare al tuo stato originale semplicemente effettuando il check-out in quel ramo. Nel mio esempio: master branch

git checkout master

Se non vuoi tornare allo stato originale e vuoi mantenere uno dei commit come testa e continuare da lì, allora devi diramare da lì. ad esempio, dopo "git checkout HEAD @ {4}", puoi emettere

git checkout -b MyNewBranch

Come soluzione alternativa, puoi semplicemente tornare a HEAD con

git checkout <branch>

E poi passa al commit che desideri, con

git checkout HEAD~<offset>

Se stai usando vs code, la cronologia di Git è un fantastico plugin in cui puoi vedere in modo efficiente i commit e controllare i loro contenuti nell'editor stesso. controlla il link

branchName=master; commitInOrder=1; git checkout $(git log --pretty=%H "${branchName}" | tac | head -n "${commitInOrder}" | tail -n 1)

dove:

branchName è uguale al nome del ramo

commitInOrder è uguale a un commit in ordine dal primo commit nel ramo selezionato (quindi 1 è il primo commit, 2 è il secondo commit nel ramo, ecc.)