Uso frequentemente git stashe git stash popper salvare e ripristinare le modifiche nel mio albero di lavoro. Ieri ho apportato alcune modifiche al mio albero di lavoro che avevo nascosto e spuntato, quindi ho apportato ulteriori modifiche al mio albero di lavoro. Vorrei tornare indietro e rivedere le modifiche apportate ieri, ma git stash popsembra rimuovere tutti i riferimenti al commit associato.

So che se uso git stashallora .git / refs / stash contiene il riferimento del commit utilizzato per creare lo stash. E .git / logs / refs / stash contiene l'intera scorta. Ma quei riferimenti sono andati dopo git stash pop. So che il commit è ancora nel mio repository da qualche parte, ma non so cosa fosse.

C'è un modo semplice per recuperare il riferimento al commit stash di ieri?

Si noti che questo non è fondamentale per me oggi perché ho backup giornalieri e posso tornare all'albero di lavoro di ieri per ottenere le mie modifiche. Lo sto chiedendo perché ci deve essere un modo più semplice!

Una volta che conosci l'hash del commit stash che hai lasciato cadere, puoi applicarlo come stash:

git stash apply $stash_hash

In alternativa, puoi creare un ramo separato per esso con

git branch recovered $stash_hash

Dopodiché, puoi fare quello che vuoi con tutti gli strumenti normali. Quando hai finito, soffia via il ramo.

Trovare l'hash

Se l'hai appena spuntato e il terminale è ancora aperto, avrai comunque il valore di hash stampato git stash popsullo schermo (grazie, Dolda).

Altrimenti, puoi trovarlo usando questo per Linux, Unix o Git Bash per Windows:

git fsck --no-reflog | awk '/dangling commit/ {print $3}'

... o usando Powershell per Windows:

git fsck --no-reflog | select-string 'dangling commit' | foreach { $bits = $_ -split ' '; echo $bits[2];}

Questo ti mostrerà tutti i commit sui suggerimenti del tuo grafico di commit che non sono più referenziati da alcun ramo o tag - ogni commit perso, incluso ogni commit stash che hai mai creato, sarà da qualche parte in quel grafico.

Il modo più semplice per trovare il commit stash che desideri è probabilmente passare l'elenco a gitk:

gitk --all $( git fsck --no-reflog | awk '/dangling commit/ {print $3}' )

... o vedi la risposta da emragins se usi Powershell per Windows.

Questo avvierà un browser di repository che mostra ogni singolo commit nel repository di sempre , indipendentemente dal fatto che sia raggiungibile o meno.

Puoi sostituirlo gitkcon qualcosa di simile git log --graph --oneline --decoratese preferisci un bel grafico sulla console su un'app GUI separata.

Per individuare i commit di stash, cerca i messaggi di commit di questo modulo:

        WIP su somebranch : commithash Alcuni vecchi messaggi di commit

Nota : il messaggio di commit sarà in questo formato (a partire da "WIP on") se non hai fornito un messaggio quando lo hai fatto git stash.

Se non hai chiuso il terminale, guarda l'output da git stash pope avrai l'ID oggetto della scorta rilasciata. Normalmente si presenta così:

$ git stash pop
[...]
Dropped refs/stash@{0} (2ca03e22256be97f9e40f08e6d6773c7d41dbfd1)

(Nota che git stash dropproduce anche la stessa linea.)

Per recuperare quella scorta, corri git branch tmp 2cae03ee la otterrai come un ramo. Per convertirlo in uno stash, esegui:

git stash apply tmp
git stash

Avendolo come un ramo ti permette anche di manipolarlo liberamente; ad esempio, per selezionarlo o unirlo alla ciliegia.

Volevo solo menzionare questa aggiunta alla soluzione accettata. Non è stato immediatamente ovvio per me la prima volta che ho provato questo metodo (forse avrebbe dovuto essere), ma per applicare lo stash dal valore hash, basta usare "git stash applicare":

$ git stash apply ad38abbf76e26c803b27a6079348192d32f52219

Quando ero nuovo di Git, questo non mi era chiaro e stavo provando diverse combinazioni di "git show", "git apply", "patch", ecc.

Per ottenere l'elenco degli stash che sono ancora nel tuo repository, ma non più raggiungibili:

git fsck --unreachable | grep commit | cut -d" " -f3 | xargs git log --merges --no-walk --grep=WIP

Se hai dato un titolo alla tua scorta, sostituisci "WIP" -grep=WIPalla fine del comando con una parte del tuo messaggio, ad es -grep=Tesselation.

Il comando sta eseguendo il grepping per "WIP" perché il messaggio di commit predefinito per uno stash è nel modulo WIP on mybranch: [previous-commit-hash] Message of the previous commit.

Ho appena creato un comando che mi ha aiutato a trovare il mio commit stash perso:

for ref in `find .git/objects | sed -e 's#.git/objects/##' | grep / | tr -d /`; do if [ `git cat-file -t $ref` = "commit" ]; then git show --summary $ref; fi; done | less

Questo elenca tutti gli oggetti nell'albero .git / objects, individua quelli di tipo commit, quindi mostra un riepilogo di ciascuno. Da questo punto era solo una questione di esaminare gli commit per trovare un "WIP on work: 6a9bb2" appropriato ("work" è il mio ramo, 619bb2 è un commit recente).

Noto che se uso "git stash apply" invece di "git stash pop" non avrei questo problema, e se uso "git stash save message " il commit potrebbe essere stato più facile da trovare.

Aggiornamento: con l'idea di Nathan, questo diventa più breve:

for ref in `git fsck --unreachable | grep commit | cut -d' ' -f3`; do git show --summary $ref; done | less

git fsck --unreachable | grep commitdovrebbe mostrare sha1, anche se l'elenco che restituisce potrebbe essere abbastanza grande. git show <sha1>mostrerà se è il commit che desideri.

git cherry-pick -m 1 <sha1> unirà il commit sul ramo corrente.

Equivalente di Windows PowerShell usando gitk:

gitk --all $(git fsck --no-reflog | Select-String "(dangling commit )(.*)" | %{ $_.Line.Split(' ')[2] })

C'è probabilmente un modo più efficiente per farlo in una pipe, ma questo fa il lavoro.

Se vuoi ridisporre una scorta perduta, devi prima trovare l'hash della scorta perduta.

Come suggerì Aristotele Pagaltzis, git fsckdovresti aiutarti.

Personalmente uso il mio log-allalias che mi mostra ogni commit (commit recuperabili) per avere una visione migliore della situazione:

git log --graph --decorate --pretty=oneline --abbrev-commit --all $(git fsck --no-reflogs | grep commit | cut -d' ' -f3)

Puoi effettuare una ricerca ancora più veloce se stai cercando solo messaggi "WIP on".

Una volta che conosci sha1, devi semplicemente cambiare il reflog di stash per aggiungere il vecchio stash:

git update-ref refs/stash ed6721d

Probabilmente preferirai avere un messaggio associato quindi a -m

git update-ref -m "$(git log -1 --pretty=format:'%s' ed6721d)" refs/stash ed6721d

E vorrai persino usarlo come alias:

restash = !git update-ref -m $(git log -1 --pretty=format:'%s' $1) refs/stash $1

Mi è piaciuto l'approccio di Aristotele, ma non mi è piaciuto usare GITK ... dato che sono abituato a usare GIT dalla riga di comando.

Invece, ho preso le commit penzolanti e l'output del codice in un file DIFF per la revisione nel mio editor di codice.

git show $( git fsck --no-reflog | awk '/dangling commit/ {print $3}' ) > ~/stash_recovery.diff

Ora puoi caricare il file diff / txt risultante (nella sua cartella home) nel tuo editor txt e vedere il codice effettivo e SHA risultante.

Quindi basta usare

git stash apply ad38abbf76e26c803b27a6079348192d32f52219

Puoi elencare tutti i commit non raggiungibili scrivendo questo comando nel terminale -

git fsck --unreachable

Verifica hash commit non raggiungibile -

git show hash

Infine, applica se trovi l'elemento nascosto -

git stash apply hash

Perché le persone fanno questa domanda? Perché non conoscono ancora o comprendono il reflog.

La maggior parte delle risposte a questa domanda fornisce lunghi comandi con opzioni che quasi nessuno ricorderà. Quindi la gente viene a questa domanda e copia incolla tutto ciò di cui pensa di aver bisogno e lo dimentica quasi subito dopo.

Consiglierei a tutti con questa domanda di controllare semplicemente il reflog (git reflog), non molto di più. Una volta visualizzato l'elenco di tutti i commit, ci sono centinaia di modi per scoprire quale commit stai cercando e selezionarlo o creare un ramo da esso. Nel processo avrai imparato a conoscere il reflog e le opzioni utili a vari comandi git di base.

In OSX con git v2.6.4, ho appena eseguito git stash drop per errore, quindi l'ho trovato andando attraverso i passaggi seguenti

Se conosci il nome della scorta, usa:

$ git fsck --unreachable | grep commit | cut -c 20- | xargs git show | grep -B 6 -A 2 <name of the stash>

altrimenti troverai l'ID del risultato manualmente con:

$ git fsck --unreachable | grep commit | cut -c 20- | xargs git show

Quindi quando trovi il commit-id basta premere il git stash applicare {commit-id}

Spero che questo aiuti qualcuno rapidamente

Voglio aggiungere alla soluzione accettata un altro buon modo per passare attraverso tutte le modifiche, quando o non hai Gitk disponibile o nessuna X per l'output.

git fsck --no-reflog | awk '/dangling commit/ {print $3}' > tmp_commits

for h in `cat tmp_commits`; do git show $h | less; done

Quindi ottieni tutte le differenze per quegli hash visualizzati uno dopo l'altro. Premi 'q' per passare al diff successivo.

Non ho potuto ottenere nessuna delle risposte per funzionare su Windows in una semplice finestra di comando (Windows 7 nel mio caso). awk, grepE Select-stringnon sono stati riconosciuti come comandi. Quindi ho provato un approccio diverso:

• prima corsa: git fsck --unreachable | findstr "commit"
• copia l'output sul blocco note
• trova sostituire "commit non raggiungibile" con start cmd /k git show

sarà simile a questo:

start cmd /k git show 8506d235f935b92df65d58e7d75e9441220537a4 start cmd /k git show 44078733e1b36962571019126243782421fcd8ae start cmd /k git show ec09069ec893db4ec1901f94eefc8dc606b1dbf1 start cmd /k git show d00aab9198e8b81d052d90720165e48b287c302e

• salva come file .bat ed eseguilo
• lo script aprirà una serie di finestre di comando, mostrando ogni commit
• se hai trovato quello che stai cercando, esegui: git stash apply (your hash)

potrebbe non essere la soluzione migliore, ma ha funzionato per me

La risposta accettata da Aristotele mostrerà tutti i commit raggiungibili, inclusi i commit non-stash. Per filtrare il rumore:

git fsck --no-reflog | \
awk '/dangling commit/ {print $3}' | \
xargs git log --no-walk --format="%H" \
  --grep="WIP on" --min-parents=3 --max-parents=3

Ciò includerà solo commit che hanno esattamente 3 commit parent (che uno stash avrà) e il cui messaggio include "WIP on".

Tieni presente che se hai salvato la scorta con un messaggio (ad es. git stash save "My newly created stash"), Questo sostituirà il messaggio predefinito "WIP su ...".

È possibile visualizzare ulteriori informazioni su ciascun commit, ad es. Visualizzare il messaggio di commit o passarlo a git stash show:

git fsck --no-reflog | \
awk '/dangling commit/ {print $3}' | \
xargs git log --no-walk --format="%H" \
  --grep="WIP on" --min-parents=3 --max-parents=3 | \
xargs -n1 -I '{}' bash -c "\
  git log -1 --format=medium --color=always '{}'; echo; \
  git stash show --color=always '{}'; echo; echo" | \
less -R

Il mio preferito è questo one-liner:

git log --oneline  $( git fsck --no-reflogs | awk '/dangling commit/ {print $3}' )

Questa è sostanzialmente la stessa idea di questa risposta, ma molto più breve. Naturalmente, puoi ancora aggiungere --graphper ottenere una visualizzazione ad albero.

Quando hai trovato il commit nell'elenco, fai domanda con

git stash apply THE_COMMIT_HASH_FOUND

Per me, l'utilizzo --no-reflogsha rivelato la voce persa, ma --unreachable(come si trova in molte altre risposte) no.

Eseguilo su git bash quando sei in Windows.

Riconoscimenti: i dettagli dei comandi precedenti sono tratti da https://gist.github.com/joseluisq/7f0f1402f05c45bac10814a9e38f81bf

Recuperato utilizzando i seguenti passaggi:

1. Identifica il codice hash stash eliminato:

   gitk --all $ (git fsck --no-reflog | awk '/ dangling commit / {print $ 3}')

2. Cherry Pick the Stash:

   git cherry-pick -m 1 $ stash_hash_code

3. Risolvi i conflitti se presenti utilizzando:

   git mergetool

Inoltre potresti avere problemi con il messaggio di commit se stai usando gerrit. Si prega di riporre le modifiche prima di seguire le prossime alternative:

1. Utilizzare il ripristino hardware per il commit precedente e quindi consigliare questa modifica.
2. Puoi anche riporre la modifica, rifare la richiesta e ricominciare.

Quello che sono venuto qui a cercare è come recuperare effettivamente la scorta, indipendentemente da ciò che ho verificato. In particolare, avevo nascosto qualcosa, poi ho verificato una versione precedente, quindi l'ho pop-up, ma la scorta era una no-op in quel momento precedente, quindi la scorta è scomparsa; Non potevo fare semplicemente git stashper rimetterlo in pila. Questo ha funzionato per me:

$ git checkout somethingOld
$ git stash pop
...
nothing added to commit but untracked files present (use "git add" to track)
Dropped refs/stash@{0} (27f6bd8ba3c4a34f134e12fe69bf69c192f71179)
$ git checkout 27f6bd8ba3c
$ git reset HEAD^    # Make the working tree differ from the parent.
$ git stash # Put the stash back in the stack.
Saved working directory and index state WIP on (no branch): c2be516 Some message.
HEAD is now at c2be516 Some message.
$ git checkout somethingOld # Now we are back where we were.

Col senno di poi, avrei usato git stash applynon git stash pop. Stavo facendo una bisecte avevo una piccola patch che volevo applicare ad ogni bisectpasso. Ora sto facendo questo:

$ git reset --hard; git bisect good; git stash apply
$ # Run tests
$ git reset --hard; git bisect bad; git stash apply
etc.