git stash -> unisce le modifiche nascoste alle modifiche correnti

Ho apportato alcune modifiche al mio ramo e mi sono reso conto che avevo dimenticato di aver nascosto alcune altre modifiche necessarie a quel ramo. Quello che voglio è un modo per unire le mie modifiche nascoste alle modifiche correnti.

C'è un modo per fare questo?

È più per comodità, alla fine ho rinunciato e impegnato prima i miei cambiamenti attuali, poi i miei cambiamenti nascosti, ma avrei preferito farli entrare in un colpo solo.

Ho appena scoperto che se le tue modifiche non confermate vengono aggiunte all'indice (cioè "messe in scena", usando git add ...), allora git stash apply(e, presumibilmente, git stash pop) si fonderanno effettivamente. Se non ci sono conflitti, sei d'oro. In caso contrario, risolverli come al solito con git mergetoolo manualmente con un editor.

Per essere chiari, questo è il processo di cui sto parlando:

mkdir test-repo && cd test-repo && git init
echo test > test.txt
git add test.txt && git commit -m "Initial version"

# here's the interesting part:

# make a local change and stash it:
echo test2 > test.txt
git stash

# make a different local change:
echo test3 > test.txt

# try to apply the previous changes:
git stash apply
# git complains "Cannot apply to a dirty working tree, please stage your changes"

# add "test3" changes to the index, then re-try the stash:
git add test.txt
git stash apply
# git says: "Auto-merging test.txt"
# git says: "CONFLICT (content): Merge conflict in test.txt"

... che è probabilmente quello che stai cercando.

tl; dr

Esegui per git addprimo.

In esecuzione git stash popo git stash applyè essenzialmente un'unione. Non avresti dovuto eseguire il commit delle modifiche correnti a meno che i file modificati nello stash non vengano modificati anche nella copia di lavoro, nel qual caso avresti visto questo messaggio di errore:

error: Your local changes to the following files would be overwritten by merge:
       file.txt
Please, commit your changes or stash them before you can merge.
Aborting

In tal caso, non è possibile applicare lo stash alle modifiche correnti in un solo passaggio. È possibile eseguire il commit delle modifiche, applicare nuovamente lo stash, eseguire nuovamente il commit e annullare quei due commit utilizzando git rebasese in realtà non si desidera eseguire due commit, ma potrebbe essere più un problema che valga la pena.

Quello che voglio è un modo per unire le mie modifiche nascoste alle modifiche correnti

Ecco un'altra opzione per farlo:

git stash show -p|git apply
git stash drop

git stash show -pmostrerà la patch dell'ultima scorta salvata. git applylo applicherà. Al termine dell'unione, è possibile eliminare lo stash unito git stash drop.

Il modo in cui lo faccio è git addprima di tutto questo git stash apply <stash code>. È il modo più semplice.

Come suggerito da @Brandan, ecco cosa dovevo fare per spostarmi

error: Your local changes to the following files would be overwritten by merge:
       file.txt
Please, commit your changes or stash them before you can merge.
Aborting

Segui questo processo:

git status  # local changes to `file`
git stash list  # further changes to `file` we want to merge
git commit -m "WIP" file
git stash pop
git commit -m "WIP2" file
git rebase -i HEAD^^  # I always use interactive rebase -- I'm sure you could do this in a single command with the simplicity of this process -- basically squash HEAD into HEAD^
# mark the second commit to squash into the first using your EDITOR
git reset HEAD^

E rimarrai con le modifiche locali completamente unite file, pronte a fare ulteriore lavoro / pulizia o fare un unico buon impegno. Oppure, se sai che i contenuti uniti di filesaranno corretti, potresti scrivere un messaggio appropriato e saltare git reset HEAD^.

Può essere, non è la peggior idea di unire (via difftool) da ... sì ... un ramo!

> current_branch=$(git status | head -n1 | cut -d' ' -f3)
> stash_branch="$current_branch-stash-$(date +%yy%mm%dd-%Hh%M)"
> git stash branch $stash_branch
> git checkout $current_branch
> git difftool $stash_branch

puoi facilmente

1. Impegna le tue attuali modifiche
2. Decomprimi la scorta e risolvi i conflitti
3. Effettua modifiche dalla scorta
4. Soft reset da cui provieni il commit (ultimo commit corretto)

Un'altra opzione è quella di fare un'altra "git stash" delle modifiche locali senza commit, quindi combinare le due stash git. Sfortunatamente git sembra non avere un modo per combinare facilmente due blocchi. Quindi un'opzione è quella di creare due file .diff e applicarli entrambi - per non dire che non è un commit extra e non comporta un processo in dieci passaggi: |

come: https://stackoverflow.com/a/9658688/32453