Nascondere solo le modifiche non programmate in Git

Vorrei fare il seguente flusso di lavoro:

1. Aggiungi modifiche allo stage.
2. Metti da parte tutte le altre modifiche che non sono state messe in scena.
3. Fare alcune cose con le cose in fase (cioè costruire, eseguire test, ecc.)
4. Applica la scorta.

C'è un modo per eseguire il passaggio 2?

Esempio

 echo "123" > foo
 git add foo # Assumes this is a git directory
 echo "456" >> foo
 git stash
 cat foo # Should yield 123

git stash saveha un'opzione --keep-indexche fa esattamente ciò di cui hai bisogno.

Quindi corri git stash save --keep-index.

Questo può essere fatto in 3 passaggi: salva le modifiche a fasi, stash tutto il resto, ripristina l'indice con modifiche a fasi. Che è fondamentalmente:

git commit -m 'Save index'
git stash push -u -m 'Unstaged changes and untracked files'
git reset --soft HEAD^

Questo farà esattamente quello che vuoi.

git stash save --keep-index

Inoltre, Re:

Perché non eseguire il commit delle modifiche dopo averle messe in scena? - Stinco

A: Perché dovresti sempre controllare il codice testato :) Ciò significa che devi eseguire i test con solo le modifiche che stai per eseguire

_{Tutto questo a parte il fatto che, naturalmente, come programmatore esperto, hai l'urgenza innata di testare e rivedere solo quei cambiamenti - solo in parte scherzando}

Con git version 2.7.4te puoi fare:

git stash save --patch

Il gitchiederà di aggiungere o meno le modifiche in scorta.
E poi rispondi yon

Puoi ripristinare la directory di lavoro come fai sempre:

git stash pop

oppure, se vuoi mantenere le modifiche salvate nella stash:

git stash apply

Nascondere solo l'albero di lavoro (modifiche non programmate) in Git è più difficile di quanto dovrebbe essere. La risposta accettata nasconde le modifiche non in scena, ma anche le modifiche in scena (e le lascia anche in scena), che raramente è ciò che desideri.

Questo alias funziona bene:

stash-working = "!f() { \
  git commit --quiet -m \"temp for stash-working\" && \
  git stash push \"$@\" && \
  git reset --quiet --soft HEAD~1; }; f"

Esegue il commit delle modifiche temporanee, crea uno stash dalle modifiche rimanenti (e consente di passare argomenti aggiuntivi come --include-untrackede --messagecome argomenti alias), quindi reimposta il commit temporaneo per ripristinare le modifiche temporanee.

E 'simile a quella di @Simon Knapp risposta , ma con alcune piccole differenze - si utilizza --quietsulle azioni temporanee indicate, e accetta qualsiasi numero di parametri per la scorta push, piuttosto che hard-codifica la -m, e lo fa aggiungere--soft alla finale reimpostare in modo che l'indice rimanga come è iniziato.

Per il problema opposto di nascondere solo le modifiche graduali (alias stash-index) vedere questa risposta .

Per aggiungere i file non archiviati (non aggiunti al commit) allo stash, eseguire il comando seguente:

git stash -k

Se desideri includere i file appena aggiunti (che non sono organizzati in fasi, non in verde) anche nella scorta, procedi come segue:

git stash -k -u

Quindi puoi eseguire il commit dei file staged. Dopodiché puoi recuperare gli ultimi file nascosti usando il comando:

git stash pop

Estendendo le risposte precedenti, a volte ho una serie complessa di modifiche organizzate, ma desidero prima eseguire una modifica separata. Ad esempio, potrei aver individuato un bug o un codice altrimenti errato che vorrei correggere prima delle modifiche in fasi. Una possibile strada da prendere è questa:

prima riponi tutto, ma lascia intatte le modifiche messe in scena

$ git stash save --keep-index [--include-untracked]

ora riponi separatamente anche le modifiche messe in scena

$ git stash save

apportare modifiche per la correzione; e prova; impegnali:

$ git add [--interactive] [--patch]

$ git commit -m "aggiusta ..."

ora ripristina le modifiche messe in scena in precedenza:

$ git stash pop

risolvere eventuali conflitti e notare che se c'erano conflitti, git avrà applicato ma non eliminato quella voce di stash superiore.

(... Quindi eseguire il commit delle modifiche in fasi e ripristinare la scorta di tutte le altre modifiche e continuare ...)

Git non dispone di un comando che memorizza solo le modifiche non organizzate.

Git, tuttavia, ti consente di specificare quali file vuoi mettere da parte.

git stash push --message 'Unstaged changes' -- app/controllers/products_controller.rb test/controllers/products_controller_test.rb

Se desideri archiviare solo modifiche specifiche in quei file, aggiungi l' --patchopzione.

git stash push --patch --message 'Unstaged changes' -- app/controllers/products_controller.rb test/controllers/products_controller_test.rb

L' --include-untrackedopzione ti consente di riporre i file non tracciati.

git stash push --include-untracked --message 'Untracked files' -- app/controllers/widgets_controller.rb test/controllers/widgets_controller_test.rb

Esegui git help stash(o man git-stash) per maggiori informazioni.

Nota: se le modifiche non organizzate sono piuttosto disoganizzate, la risposta di @ alesguzik è probabilmente più semplice.

Un altro suggerimento, relativo alla domanda:

Quando riponi in modo efficace le modifiche non organizzate utilizzando

$ git stash save --keep-index

potresti voler dare un messaggio alla scorta, in modo che quando fai una git stash listè più ovvio cosa hai nascosto prima, specialmente se segui quell'operazione di scorta con ulteriori salvataggi. Per esempio

$ git stash save --keep-index "modifiche non ancora messe in scena"

(sebbene in realtà contenga tutte le modifiche come indicato in altre risposte).

Ad esempio, quanto sopra potrebbe essere seguito immediatamente da:

$ git stash save "modifiche graduali per la funzione X"

Attenzione, però, che non puoi usare

$ git stash apply "stash @ {1}" ### ✘ non fa proprio quello che potresti desiderare

per ripristinare solo le modifiche non programmate.

Uso un alias, che accetta una stringa da utilizzare come messaggio per la voce stash.

mystash = "!f() { git commit -m hold && git stash push -m \"$1\" && git reset HEAD^; }; f"

Quale:

• esegue il commit di tutto nell'indice,
• nasconde ciò che è cambiato nell'albero di lavoro (potrebbe ovviamente aggiungere -uo-a ),
• ripristina l'ultimo commit al tentativo di lavoro (potrebbe essere necessario utilizzarlo --softper mantenerlo nell'indice).

La forma moderna di quel comando è git stash push [--] [<pathspec>...], poiché Git 2.16+ ( git stash saveè deprecato )

Puoi combinarlo con un formato jolly, ad esempio:

git stash push --all --keep-index ':(glob)**/*.testextension' 

Ma questo non funziona bene con Git per Windows, fino a Git 2.22 (Q2 2019), vedere il numero 2037 , considerando che git stashè stato reimplementato in C (invece di uno script di shell)

Vedere il commit 7db9302 (11 marzo 2019) di Thomas Gummerer ( tgummerer) .
Vedere commit 1366c78 , commit 7b556aa (07 marzo 2019) di Johannes Schindelin ( dscho) .
^{(Fuso da Junio ​​C Hamano - gitster- in commit 0ba1ba4 , 22 aprile 2019)}

built-in stash: gestisce :(glob)nuovamente pathspecs

Quando si passa un elenco di pathspec, diciamo, git adddobbiamo stare attenti a usare il modulo originale, non il formato analizzato di pathspecs.

Questo fa la differenza, ad esempio, quando si chiama

git stash -- ':(glob)**/*.txt'

dove il modulo originale include il :(glob)prefisso mentre il modulo analizzato no.

Tuttavia, nel built-in git stash, abbiamo passato il modulo analizzato (cioè errato) e git addnon riusciremmo con il messaggio di errore:

fatal: pathspec '**/*.txt' did not match any files

nella fase in cui git stashrilascia le modifiche dall'albero di lavoro, anche se refs/stashè stato effettivamente aggiornato con successo.