Wie kann ich nur eine von mehreren geänderten Dateien in meinem Zweig speichern?

Haftungsausschluss : Die folgende Antwort gilt für Git vor Git 2.13. Schauen Sie sich für Git 2.13 und höher eine weitere Antwort weiter unten an .

Warnung

Wie in den Kommentaren erwähnt, wird dadurch alles inszeniert, sowohl inszeniert als auch nicht inszeniert. Der --keep-Index lässt den Index nach Abschluss des Stashs einfach in Ruhe. Dies kann zu Zusammenführungskonflikten führen, wenn Sie den Stash später öffnen.

Dadurch wird alles gespeichert, was Sie zuvor noch nicht hinzugefügt haben. Nur git adddie Dinge, die Sie behalten möchten, und dann ausführen.

git stash --keep-index

Wenn Sie beispielsweise ein altes Commit in mehrere Änderungssätze aufteilen möchten, können Sie folgende Prozedur verwenden:

1. git rebase -i <last good commit>
2. Markieren Sie einige Änderungen als edit.
3. git reset HEAD^
4. git add <files you want to keep in this change>
5. git stash --keep-index
6. Repariere die Dinge nach Bedarf. Vergessen Sie git addkeine Änderungen.
7. git commit
8. git stash pop
9. Wiederholen Sie dies nach Bedarf ab Nr. 5.
10. git rebase --continue

Sie können auch verwenden git stash save -p "my commit message" . Auf diese Weise können Sie auswählen, welche Hunks zum Stash hinzugefügt werden sollen. Es können auch ganze Dateien ausgewählt werden.

Sie werden mit ein paar Aktionen für jedes Stück aufgefordert:

   y - stash this hunk
   n - do not stash this hunk
   q - quit; do not stash this hunk or any of the remaining ones
   a - stash this hunk and all later hunks in the file
   d - do not stash this hunk or any of the later hunks in the file
   g - select a hunk to go to
   / - search for a hunk matching the given regex
   j - leave this hunk undecided, see next undecided hunk
   J - leave this hunk undecided, see next hunk
   k - leave this hunk undecided, see previous undecided hunk
   K - leave this hunk undecided, see previous hunk
   s - split the current hunk into smaller hunks
   e - manually edit the current hunk
   ? - print help

Da es bei git im Wesentlichen um die Verwaltung des gesamten Repository- Inhalts und -Index (und nicht einer oder mehrerer Dateien) geht, git stashhandelt es sich nicht überraschend ummit dem gesamten Arbeitsverzeichnis.

Seit Git 2.13 (Q2 2017) können Sie einzelne Dateien mit git stash pushfolgenden Elementen speichern :

git stash push [--] [<pathspec>...]

Wenn pathspec' git stash push' angegeben wird, zeichnet der neue Stash die geänderten Zustände nur für die Dateien auf, die der Pfadspezifikation entsprechen. Weitere Informationen finden Sie unter " Stash-Änderungen an bestimmten Dateien ".

Vereinfachtes Beispiel:

 git stash push path/to/file

Der Testfall für diese Funktion zeigt einige weitere Optionen:

test_expect_success 'stash with multiple pathspec arguments' '
    >foo &&
    >bar &&
    >extra &&
    git add foo bar extra &&

    git stash push -- foo bar &&   

    test_path_is_missing bar &&
    test_path_is_missing foo &&
    test_path_is_file extra &&

    git stash pop &&
    test_path_is_file foo &&
    test_path_is_file bar &&
    test_path_is_file extra

Bei der ursprünglichen Antwort (unten, Juni 2010) ging es darum, manuell auszuwählen, was Sie verstauen möchten.

Casebash- Kommentare:

Dies (die stash --patchursprüngliche Lösung) ist nett, aber oft habe ich viele Dateien geändert, so dass die Verwendung von Patches ärgerlich ist

bukzor ‚s Antwort (upvoted November 2011) schlägt vor , eine praktischere Lösung, basierend auf
git add+git stash --keep-index .
Gehen Sie und sehen Sie seine Antwort, die die offizielle sein sollte (anstelle meiner).

Zu dieser Option weist chhh in den Kommentaren auf einen alternativen Workflow hin:

Sie sollten git reset --softnach einem solchen Vorrat " " " " tun, um Ihre klare Inszenierung wiederherzustellen:
Um zum ursprünglichen Zustand zurückzukehren - der ein klarer Staging-Bereich ist und nur einige ausgewählte nicht inszenierte Modifikationen enthält, können Sie den Index sanft zurücksetzen, um ihn zu erhalten (ohne) etwas wie Sie zu begehen - bukzor - tat).

(Ursprüngliche Antwort Juni 2010: manuelle Aufbewahrung)

Dennoch git stash save --patchkonnte ermöglicht es Ihnen , die teilweise stashing erreichen Sie nach:

Mit --patchkönnen Sie interaktiv Hunks aus dem Diff zwischen HEAD und dem zu verstauenden Arbeitsbaum auswählen.
Der Stash-Eintrag ist so aufgebaut, dass sein Indexstatus mit dem Indexstatus Ihres Repositorys übereinstimmt und sein Arbeitsbaum nur die Änderungen enthält, die Sie interaktiv ausgewählt haben. Die ausgewählten Änderungen werden dann von Ihrem Arbeitsbaum zurückgesetzt.

Dadurch werden jedoch der vollständige Index (der möglicherweise nicht Ihren Wünschen entspricht, da er möglicherweise andere bereits indizierte Dateien enthält) und ein Teilarbeitsbaum (der möglicherweise so aussieht wie der, den Sie speichern möchten) gespeichert.

git stash --patch --no-keep-index

könnte besser passen.

Wenn --patchdies nicht funktioniert, kann ein manueller Vorgang Folgendes bewirken:

Für eine oder mehrere Dateien wäre eine Zwischenlösung:

• kopiere sie außerhalb des Git-Repos
  (Eigentlich schlägt eleotlecram eine interessante Alternative vor )
• git stash
• kopiere sie zurück
• git stash # Dieses Mal werden nur die gewünschten Dateien gespeichert
• git stash pop stash@{1} # Wenden Sie alle Änderungen an Ihren Dateien erneut an
• git checkout -- afile # Setzen Sie die Datei vor lokalen Änderungen auf den HEAD-Inhalt zurück

Am Ende dieses ziemlich umständlichen Prozesses werden nur eine oder mehrere Dateien gespeichert.

Wenn git stash -p(oder git add -pmit stash --keep-index) zu umständlich wäre, fand ich es einfacher zu bedienen diff, checkoutund apply:

So "verstauen" Sie nur eine bestimmte Datei / ein bestimmtes Verzeichnis:

git diff path/to/dir > stashed.diff
git checkout path/to/dir

Dann danach

git apply stashed.diff

Verwenden Sie git stash pushwie folgt:

git stash push [--] [<pathspec>...]

Zum Beispiel:

git stash push -- my/file.sh

Dies ist seit Git 2.13 verfügbar, das im Frühjahr 2017 veröffentlicht wurde.

Angenommen, Sie haben 3 Dateien

a.rb
b.rb
c.rb

und du willst nur b.rb und c.rb verstauen, aber nicht a.rb.

Sie können so etwas tun

# commit the files temporarily you don't want to stash
git add a.rb
git commit -m "temp" 

# then stash the other files
git stash save "stash message"

# then undo the previous temp commit
git reset --soft HEAD^
git reset

Und du bist fertig! HTH.

Ein anderer Weg, dies zu tun:

# Save everything
git stash 

# Re-apply everything, but keep the stash
git stash apply

git checkout <"files you don't want in your stash">

# Save only the things you wanted saved
git stash

# Re-apply the original state and drop it from your stash
git stash apply stash@{1}
git stash drop stash@{1}

git checkout <"files you put in your stash">

Ich habe mir das ausgedacht, nachdem ich (noch einmal) auf diese Seite gekommen bin und die ersten beiden Antworten nicht gemocht habe (die erste Antwort beantwortet die Frage einfach nicht und ich habe es nicht ganz gemocht, mit dem -pinteraktiven Modus zu arbeiten).

Die Idee entspricht der von @VonC vorgeschlagenen Verwendung von Dateien außerhalb des Repositorys. Sie speichern die gewünschten Änderungen irgendwo, entfernen die nicht gewünschten Änderungen in Ihrem Vorrat und wenden die Änderungen, die Sie aus dem Weg geräumt haben, erneut an. Ich habe jedoch den Git-Stash als "irgendwo" verwendet (und als Ergebnis gibt es am Ende einen zusätzlichen Schritt: Entfernen der Cahnges, die Sie in den Stash gelegt haben, weil Sie diese ebenfalls aus dem Weg geräumt haben).

Update (14.02.2015) - Ich habe das Skript ein wenig umgeschrieben, um den Fall von Konflikten besser zu behandeln, die jetzt als nicht zusammengeführte Konflikte und nicht als .rej-Dateien dargestellt werden sollten.

Ich finde es oft intuitiver, das Gegenteil von @ bukzors Ansatz zu tun. Das heißt, einige Änderungen zu inszenieren und dann nur diese inszenierten Änderungen zu speichern.

Leider bietet git keinen Git-Stash - nur Index oder ähnliches, deshalb habe ich ein Skript erstellt, um dies zu tun.

#!/bin/sh

# first, go to the root of the git repo
cd `git rev-parse --show-toplevel`

# create a commit with only the stuff in staging
INDEXTREE=`git write-tree`
INDEXCOMMIT=`echo "" | git commit-tree $INDEXTREE -p HEAD`

# create a child commit with the changes in the working tree
git add -A
WORKINGTREE=`git write-tree`
WORKINGCOMMIT=`echo "" | git commit-tree $WORKINGTREE -p $INDEXCOMMIT`

# get back to a clean state with no changes, staged or otherwise
git reset -q --hard

# Cherry-pick the index changes back to the index, and stash.
# This cherry-pick is guaranteed to succeed
git cherry-pick -n $INDEXCOMMIT
git stash

# Now cherry-pick the working tree changes. This cherry-pick may fail
# due to conflicts
git cherry-pick -n $WORKINGCOMMIT

CONFLICTS=`git ls-files -u`
if test -z "$CONFLICTS"; then
    # If there are no conflicts, it's safe to reset, so that
    # any previously unstaged changes remain unstaged
    #
    # However, if there are conflicts, then we don't want to reset the files
    # and lose the merge/conflict info.
    git reset -q
fi

Sie können das obige Skript als git-stash-indexirgendwo auf Ihrem Pfad speichern und es dann als Git-Stash-Index aufrufen

# <hack hack hack>
git add <files that you want to stash>
git stash-index

Jetzt enthält der Stash einen neuen Eintrag, der nur die Änderungen enthält, die Sie bereitgestellt haben, und Ihr Arbeitsbaum enthält weiterhin alle nicht bereitgestellten Änderungen.

In einigen Fällen können die Änderungen des Arbeitsbaums von den Indexänderungen abhängen. Wenn Sie also die Indexänderungen speichern, treten bei den Änderungen des Arbeitsbaums Konflikte auf. In diesem Fall erhalten Sie die üblichen nicht zusammengeführten Konflikte, die Sie mit git merge / git mergetool / etc. Lösen können.

Wenn Sie keine Nachricht mit Ihren versteckten Änderungen angeben möchten, übergeben Sie den Dateinamen nach einem Doppelstrich.

$ git stash -- filename.ext

Wenn es sich um eine nicht verfolgte / neue Datei handelt, müssen Sie sie zuerst bereitstellen.

Diese Methode funktioniert in Git-Versionen 2.13+

Da das Erstellen von Zweigen in Git trivial ist, können Sie einfach einen temporären Zweig erstellen und die einzelnen Dateien darin einchecken.

Sie können dies einfach tun:

git stash push "filename"

oder mit einer optionalen Nachricht

git stash push -m "Some message" "filename"

Speichern Sie den folgenden Code in einer Datei mit dem Namen stash. Verwendung ist stash <filename_regex>. Das Argument ist der reguläre Ausdruck für den vollständigen Pfad der Datei. Zum Beispiel, um a / b / c.txt stash a/b/c.txtoder stash .*/c.txtusw. zu verstauen .

$ chmod +x stash
$ stash .*.xml
$ stash xyz.xml

Code zum Kopieren in die Datei:

#! /usr/bin/expect --
log_user 0
set filename_regexp [lindex $argv 0]

spawn git stash -p

for {} 1 {} {
  expect {
    -re "diff --git a/($filename_regexp) " {
      set filename $expect_out(1,string)
    }
    "diff --git a/" {
      set filename ""
    }
    "Stash this hunk " {
      if {$filename == ""} {
        send "n\n"
      } else {
        send "a\n"
        send_user "$filename\n"
      }
    }
    "Stash deletion " {
      send "n\n"
    }
    eof {
      exit
    }
  }
}

Nur für den Fall, dass Sie tatsächlich Änderungen verwerfen möchten, wann immer Sie sie verwenden git stash(und Git Stash nicht wirklich verwenden, um sie vorübergehend zu speichern), können Sie sie in diesem Fall verwenden

git checkout -- <file>

[ HINWEIS ]

Das git stashist nur eine schnellere und einfachere Alternative zum Verzweigen und Ausführen.

Das Problem bei VonCs "Zwischen" -Lösung zum Kopieren von Dateien außerhalb des Git-Repos besteht darin, dass Sie Pfadinformationen verlieren, was das spätere Zurückkopieren einer Reihe von Dateien etwas mühsam macht.

Es ist einfacher, tar zu verwenden (ähnliche Tools werden es wahrscheinlich tun) als zu kopieren:

• tar cvf /tmp/stash.tar Pfad / zu / einigen / Dateipfad / zu / einigen / anderen / Dateien (... usw.)
• Git Checkout-Pfad / zu / einigen / Dateipfad / zu / einigen / anderen / Dateien
• git stash
• tar xvf /tmp/stash.tar
• usw. (siehe VonCs "Zwischen" -Vorschlag)

Manchmal habe ich eine nicht verwandte Änderung an meinem Zweig vorgenommen, bevor ich sie festgeschrieben habe, und ich möchte sie in einen anderen Zweig verschieben und separat festschreiben (wie Master). Ich mache das:

git stash
git checkout master
git stash pop
git add <files that you want to commit>
git commit -m 'Minor feature'
git stash
git checkout topic1
git stash pop
...<resume work>...

Beachten Sie, dass das erste stash& stash popbeseitigt werden kann. Sie können alle Ihre Änderungen auf das übertragenmaster beim Auschecken Filiale übertragen, jedoch nur, wenn keine Konflikte vorliegen. Auch wenn Sie einen neuen Zweig für die Teiländerungen erstellen, benötigen Sie den Stash.

Sie können es vereinfachen, indem Sie keine Konflikte und keinen neuen Zweig annehmen:

git checkout master
git add <files that you want to commit>
git commit -m 'Minor feature'
git checkout topic1
...<resume work>...

Versteck nicht einmal benötigt ...

Dies kann mit SourceTree in 3 Schritten einfach durchgeführt werden.

1. Legen Sie vorübergehend alles fest, was Sie nicht verstauen möchten.
2. Git alles andere hinzufügen, dann verstauen.
3. Pop Ihr ​​temporäres Commit, indem Sie git reset ausführen und das Commit vor Ihrem temporären festsetzen.

Dies alles kann in SourceTree in Sekundenschnelle erledigt werden, wo Sie einfach auf die Dateien (oder sogar einzelne Zeilen) klicken können, die Sie hinzufügen möchten. Einmal hinzugefügt, verpflichten Sie sie einfach zu einem temporären Commit. Klicken Sie anschließend auf das Kontrollkästchen, um alle Änderungen hinzuzufügen, und klicken Sie dann auf Stash, um alles zu speichern. Wenn die versteckten Änderungen nicht im Weg sind, werfen Sie einen Blick auf Ihre Festschreibungsliste und notieren Sie sich den Hash für das Festschreiben vor Ihrem temporären Festschreiben. Führen Sie dann "git reset hash_b4_temp_commit" aus direkt davor begehen. Jetzt haben Sie nur noch das Zeug, das Sie nicht verstauen wollten.

Ich würde verwenden git stash save --patch. Ich finde die Interaktivität nicht ärgerlich, da es währenddessen Optionen gibt, um den gewünschten Vorgang auf ganze Dateien anzuwenden.

Jede Antwort hier ist so kompliziert ...

Was ist damit zu "verstauen":

git diff /dir/to/file/file_to_stash > /tmp/stash.patch
git checkout -- /dir/to/file/file_to_stash

Dies, um die Dateiänderung zurückzusetzen:

git apply /tmp/stash.patch

Genau das gleiche Verhalten wie beim Verstauen einer Datei und beim erneuten Einlegen.

Ich habe Antworten und Kommentare zu diesem und einer Reihe ähnlicher Themen überprüft. Beachten Sie, dass keiner der folgenden Befehle korrekt ist, um bestimmte verfolgte / nicht verfolgte Dateien speichern zu können :

• git stash -p (--patch): Wählen Sie Hunks manuell aus, ausgenommen nicht verfolgte Dateien
• git stash -k (--keep-index): Verstecke alle verfolgten / nicht verfolgten Dateien und behalte sie im Arbeitsverzeichnis
• git stash -u (--include-untracked): Versteckt alle verfolgten / nicht verfolgten Dateien
• git stash -p (--patch) -u (--include-untracked): ungültiger Befehl

Derzeit ist die vernünftigste Methode, um bestimmte verfolgte / nicht verfolgte Dateien zu speichern, folgende:

• Übernehmen Sie vorübergehend die Dateien, die Sie nicht speichern möchten
• Hinzufügen und verstauen
• Pop das temporäre Commit

Ich habe ein einfaches Skript für diese Prozedur in einer Antwort auf eine andere Frage geschrieben , und hier finden Sie Schritte zum Ausführen der Prozedur in SourceTree .

Lösung

Lokale Änderungen:

• file_A (geändert) nicht bereitgestellt
• file_B (geändert) nicht bereitgestellt
• file_C (geändert) nicht bereitgestellt

So erstellen Sie einen Stash "my_stash" mit nur den Änderungen in file_C :

1. git add file_C
2. git stash save --keep-index temp_stash
3. git stash save my_stash
4. git stash pop stash@#{1}

Erledigt.

Erläuterung

1. hinzufügen file_C in den Staging - Bereich
2. Erstellen Sie einen temporären Stash mit dem Namen "temp_stash" und behalten Sie die Änderungen in file_C bei
3. Erstellen Sie den gewünschten Stash ("my_stash") nur mit den Änderungen in file_C
4. Wenden Sie die Änderungen in "temp_stash" (file_A und file_B) auf Ihren lokalen Code an und löschen Sie den Stash

Sie können den Git-Status zwischen den Schritten verwenden, um zu sehen, was los ist.

Wenn Sie versuchen, zwischen zwei Zweigen zu wechseln, tritt diese Situation auf.

Versuchen Sie, die Dateien mit " git add filepath" hinzuzufügen .

Führen Sie diese Zeile später aus

git stash --keep-index

Um eine einzelne Datei zu verstauen, verwenden Sie git stash --patch [file].

Dies wird dazu auffordern : Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?. aGeben Sie einfach ein (verstauen Sie dieses Stück und alle späteren Stücke in der Datei) und schon geht es Ihnen gut.

Ähnliche Situation. Hat sich verpflichtet und festgestellt, dass es nicht in Ordnung ist.

git commit -a -m "message"
git log -p

Aufgrund der Antworten hat mir das geholfen.

# revert to previous state, keeping the files changed
git reset HEAD~
#make sure it's ok
git diff
git status
#revert the file we don't want to be within the commit
git checkout specs/nagios/nagios.spec
#make sure it's ok
git status
git diff
#now go ahead with commit
git commit -a -m "same|new message"
#eventually push tu remote
git push

In dieser Situation habe ich git add -p(interaktiv) git commit -m blahund dann bei Bedarf verstaut, was noch übrig ist.

Ich weiß nicht, wie ich es in der Kommandozeile machen soll, nur mit SourceTree. Nehmen wir an, Sie haben Datei A geändert und haben zwei Änderungsblöcke in Datei B. Wenn Sie nur den zweiten Teil in Datei B speichern und alles andere unberührt lassen möchten, gehen Sie folgendermaßen vor:

1. Alles inszenieren
2. Nehmen Sie Änderungen an Ihrer Arbeitskopie vor, die alle Änderungen in Datei A rückgängig machen (z. B. das externe Diff-Tool starten und die Dateien übereinstimmen lassen.)
3. Lassen Sie Datei B so aussehen, als würde nur eine zweite Änderung darauf angewendet. (z. B. externes Diff-Tool starten und erste Änderung rückgängig machen.)
4. Erstellen Sie einen Stash mit "Bereitgestellte Änderungen beibehalten".
5. Alles hinter die Bühne bringen
6. Erledigt!

git add .                           //stage all the files
git reset <pathToFileWillBeStashed> //unstage file which will be stashed
git stash                           //stash the file(s)
git reset .                         // unstage all staged files
git stash pop                       // unstash file(s)

Ein komplizierter Weg wäre, zuerst alles zu begehen:

git add -u
git commit // creates commit with sha-1 A

Zurück zum ursprünglichen Commit zurücksetzen, aber die_one_file aus dem neuen Commit auschecken:

git reset --hard HEAD^
git checkout A path/to/the_one_file

Jetzt können Sie die_one_file verstauen:

git stash

Bereinigen Sie, indem Sie den festgeschriebenen Inhalt in Ihrem Dateisystem speichern und auf das ursprüngliche Festschreiben zurücksetzen:

git reset --hard A
git reset --soft HEAD^

Ja, etwas umständlich ...

Ich fand keine Antwort als das, was ich brauchte und das ist so einfach wie:

git add -A
git reset HEAD fileThatYouWantToStash
git commit -m "committing all but one file"
git stash

Dadurch wird genau eine Datei gespeichert.

Schnelle Antwort

Um eine bestimmte geänderte Datei in git zurückzusetzen, können Sie die folgende Zeile ausführen:

git checkout <branch-name> -- <file-path>

Hier ist ein aktuelles Beispiel:

git checkout master -- battery_monitoring/msg_passing.py

Wenn Sie einige geänderte Dateien speichern möchten, einfach nur

Fügen Sie die Dateien, die Sie nicht speichern möchten, in Stage hinzu und führen Sie sie dann ausgit stash save --keep-index

Es werden alle nicht bereitgestellten geänderten Dateien gespeichert