Disclaimer: następująca odpowiedź dotyczy git przed git 2.13. Jeśli chodzi o git 2.13 i nowsze, sprawdź inną odpowiedź w dół .

Warning

Jak wspomniano w komentarzach, to umieszcza wszystko w skrytce, zarówno zainscenizowane, jak i nieakcentowane. --Keep-index zostawia tylko indeks po skończeniu skrytki. Może to spowodować konflikty scalania, gdy później otworzysz skrytkę.

To ukryje wszystko, czego nie masz poprzednio dodane. Po prostu rzeczy, które chcesz zatrzymać, a następnie uruchomić.

git stash --keep-index

Na przykład, jeśli chcesz podzielić Stary commit na więcej niż jeden zestaw zmian, możesz użyć tej procedury:

1. git rebase -i <last good commit>
2. Oznacz niektóre zmiany jako edit.
3. git reset HEAD^
4. git add <files you want to keep in this change>
5. git stash --keep-index
6. napraw wszystko w razie potrzeby. Nie zapomnij git add żadnych zmian.
7. git commit
8. git stash pop
9. Repeat, from # 5, as konieczne.
10. git rebase --continue

Od wersji Git 2.13 (Q2 2017), możesz przechowywać pojedyncze pliki, z git stash push:

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

Gdy pathspec jest podane do 'git stash push', Nowy stash zapisuje zmodyfikowane stany tylko dla plików, które pasują do pathspec Zobacz " Ukryj zmiany w określonych plikach ", aby uzyskać więcej informacji.

Uproszczony przykład:

 git stash push path/to/file

Przypadek testowy dla tej funkcji pokazuje jeszcze kilka opcji wyłączonych:

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

Oryginalna odpowiedź (poniżej, czerwiec 2010) była o ręczne wybieranie tego, co chcesz ukryć.

Casebash komentarze:

To (stash --patch oryginalne rozwiązanie) jest fajne, ale często modyfikowałem wiele plików, więc używanie patcha jest irytujące

Bukzor ' S answer (upvoted, listopad 2011) sugeruje bardziej praktyczne rozwiązanie, oparte na
git add + git stash --keep-index.
Idź zobaczyć i głosuj na jego odpowiedź, która powinna być oficjalna (zamiast mojej).

O tej opcji, chhh wskazuje alternatywny przepływ pracy w komentarzach:

Powinieneś "git reset --soft" po takim schowku, aby odzyskać swoją czystą inscenizację:
Aby dostać się do pierwotnego stanu-który jest czystym miejscem postoju i tylko z niektórymi wybranymi modyfikacjami, można delikatnie zresetować indeks, aby uzyskać (bez popełniania czegoś takiego , jak ty-bukzor-zrobił).

(oryginalna odpowiedź czerwiec 2010: manual stash)

Jednak git stash save --patch może pozwolić ci osiągnięcie częściowego schowania, którego szukasz:

Za pomocą --patch Możesz interaktywnie wybierać kawałki z różnicy między głową a drzewem roboczym, które mają być schowane.
Pozycja skrytki jest skonstruowana w taki sposób, że jej stan indeksu jest taki sam jak stan indeksu repozytorium, a jej obszar roboczy zawiera tylko zmiany wybrane interaktywnie. Wybrane zmiany są następnie wycofywane z obszaru roboczego.

Jednak to zapisze pełny indeks (który może nie być to, czego chcesz, ponieważ może zawierać inne pliki już zindeksowane) i częściowe drzewo robocze (które może wyglądać jak ten, który chcesz ukryć).

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

Może lepiej pasuje.

Dla jednego lub kilku plików rozwiązaniem pośrednim byłoby:

• skopiuj je poza Git repo
  (Właściwie eleotlecram proponuje ciekawe alternatywa )
• git stash
• skopiuj je z powrotem
• git stash # Tym razem, tylko pliki, które chcesz są ukryte
• git stash pop stash@{1} # ponownie zastosuj wszystkie modyfikacje plików
• git checkout -- afile # zresetuj plik do zawartości nagłówka, przed jakimikolwiek lokalnymi modyfikacjami

Pod koniec tego dość uciążliwego procesu, będziesz miał tylko jeden lub kilka plików przechowywanych.

Kiedy git stash -p (lub git add -p z stash --keep-index) byłoby zbyt uciążliwe, okazało się, że łatwiejsze w użyciu diff, checkout i apply:

Do "ukrycia" tylko określonego pliku / katalogu:

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

Potem

git apply stashed.diff

Użyj git stash push, tak:

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

Na przykład:

git stash push -- my/file.sh

jest to dostępne od wersji Git 2.13, wydanej wiosną 2017 roku.

Powiedzmy, że masz 3 Pliki

a.rb
b.rb
c.rb

I chcesz schować tylko b.RB i c.rb, ale nie a. RB

Możesz zrobić coś takiego

# 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

Inny sposób na to:

# 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">

Wymyśliłem to po tym, jak (po raz kolejny) przyszedłem na tę stronę i nie podobały mi się dwie pierwsze odpowiedzi (pierwsza odpowiedź po prostu nie odpowiada na pytanie i nie bardzo lubiłem pracować z -p Tryb interaktywny).

Pomysł jest taki sam, jak sugerował @VonC używając plików spoza repozytorium, zapisujesz zmiany, które chcesz gdzieś, usuwasz zmiany, których nie chcesz w skrytce, a następnie ponownie zastosuj zmiany, które przeniosłeś z repozytorium sposób. Jednak użyłem git stash jako" somewhere " (i w rezultacie na końcu jest jeszcze jeden dodatkowy krok: usunięcie cahngów, które włożyłeś do schowka, ponieważ je również usunąłeś).

Jeśli nie chcesz podawać wiadomości z ukrytymi zmianami, podaj nazwę pliku po podwójnym myślniku.

$ git stash -- filename.ext

Jeśli jest to nie śledzony / nowy plik, musisz go najpierw ustawić.

Ta metoda działa w wersji git 2.13 +

Update (2/14/2015) - trochę przepisałem skrypt, aby lepiej radzić sobie z konfliktami, które powinny być teraz przedstawiane jako niezwiązane konflikty, a nie .akta rej.

Często wydaje mi się bardziej intuicyjne, aby zrobić odwrotność podejścia @ bukzor. Oznacza to, że aby wprowadzić pewne zmiany, a następnie ukryć tylko te zainscenizowane zmiany.

Niestety, git nie oferuje git stash --only-index lub podobnych, więc stworzyłem skrypt, aby to zrobić.

#!/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

Możesz zapisać powyższy skrypt jako git-stash-index gdzieś na twojej ścieżce, a następnie możesz go wywołać jako git stash-index

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

Teraz skrytka zawiera nowy wpis, który zawiera tylko zmiany, które wystawiłeś, a twoje działające drzewo nadal zawiera wszelkie zmiany nie zmieniane.

W niektórych przypadkach zmiany w drzewie roboczym mogą zależeć od zmian w indeksie, więc kiedy schowasz zmiany w drzewie roboczym, zmiany w drzewie roboczym mają konflikt. W tym przypadku, otrzymasz zwykłe nierozwiązane konflikty, które możesz rozwiązać za pomocą git merge / git mergetool / etc.

Ponieważ tworzenie gałęzi w Git jest banalne, możesz po prostu utworzyć tymczasową gałąź i sprawdzić poszczególne pliki w niej.

Możesz po prostu to zrobić:

git stash push "filename"

Lub z opcjonalnym Komunikatem

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

Zapisz poniższy kod do pliku, na przykład o nazwie stash. Użycie to stash <filename_regex>. Argument jest wyrażeniem regularnym dla pełnej ścieżki pliku. Na przykład, aby ukryć a/b/c.txt, stash a/b/c.txt lub stash .*/c.txt, itd.

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

Kod do skopiowania do pliku:

#! /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
    }
  }
}

W przypadku, gdy masz na myśli Odrzuć zmiany za każdym razem, gdy używasz git stash (i tak naprawdę nie używasz git stash, aby ukryć je tymczasowo), w takim przypadku możesz użyć

git checkout -- <file>

[Uwaga ]

Problem z "pośrednim" rozwiązaniem vonc polegającym na kopiowaniu plików poza Git repo polega na tym, że tracisz informacje o ścieżce, co sprawia, że kopiowanie kilku plików z powrotem później jest trochę kłopotliwe.

A znaleźć łatwiejsze w użyciu tar (podobne narzędzia prawdopodobnie zrobią) zamiast kopiować:

• tar cvf / tmp / stash.tar path/to / some / file path / to / some / other / file (... itd.)
• git checkout path / to/some / file path / to/some/other / file
• git stash
• tar xvf / tmp / stash.tar
• itd. (zobacz sugestię vonc ' s "intermediate")

Jeśli chcesz ukryć tylko niektóre ze zmienionych plików, po prostu dodaj inne pliki w etapie , a następnie wykonaj git stash save --keep-index

Ukryje wszystkie nieakstragowane zmienione pliki

Czasami dokonałem niepowiązanej zmiany w mojej gałęzi, zanim ją popełniłem, i chcę przenieść ją do innej gałęzi i zatwierdzić osobno (jak master). Robię to:

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>...

Uwaga pierwsza stash & stash pop można je wyeliminować, można przenieść wszystkie zmiany do gałęzi master podczas realizacji transakcji, ale tylko wtedy, gdy nie ma konfliktów. Również jeśli tworzysz nową gałąź dla częściowych zmian, będziesz potrzebował skrytki.

Można to uprościć zakładając, że nie ma konfliktów i brak nowej gałęzi: {]}

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

Schowek nawet nie jest potrzebny...

Można to łatwo zrobić w 3 krokach używając SourceTree.

1. tymczasowo Zatwierdź wszystko, czego nie chcesz ukryć.
2. Git dodaj Wszystko inne, a następnie schowaj to.
3. Pop twój tymczasowy commit, uruchamiając git reset, targetując commit przed Twoim tymczasowym.

To wszystko można zrobić w ciągu kilku sekund w SourceTree, gdzie możesz po prostu kliknąć na pliki (lub nawet poszczególne linie), które chcesz dodać. Po dodaniu, po prostu zatwierdź je do tymczasowego zatwierdzenia. Następnie kliknij pole wyboru, aby dodać wszystkie zmiany, a następnie kliknij Schowaj, aby ukryć wszystko. Z ukrytymi zmianami, przejrzyj listę zmian i zanotuj hash dla zmian przed tymczasowym zatwierdzeniem, a następnie uruchom 'Git reset hash_b4_temp_commit', co w zasadzie przypomina "popping" commit przez zresetowanie gałęzi do commita tuż przed nim. Zostałaś z rzeczami, których nie chciałaś schować.

Użyłbym git stash save --patch. Nie uważam interaktywności za irytującą, ponieważ istnieją opcje podczas niej, aby zastosować żądaną operację do całych plików.

Każda odpowiedź tutaj jest tak skomplikowana...

A co z tym do "schowka":

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

To, aby zmienić plik z powrotem:

git apply /tmp/stash.patch

Dokładnie takie samo zachowanie jak przechowywanie jednego pliku i wrzucanie go z powrotem.

Przejrzałem odpowiedzi i komentarze do tego i wielu podobnych wątków. Należy pamiętać, że żadne z poniższych poleceń nie jest poprawne w celu ukrycia konkretnych śledzonych / nie śledzonych plików :

• git stash -p (--patch): zaznaczanie plików ręcznie, z wyłączeniem plików nie śledzonych
• git stash -k (--keep-index): Przechowuj wszystkie śledzone / nie śledzone pliki i przechowuj je w katalogu roboczym
• git stash -u (--include-untracked): Przechowuj wszystkie śledzone / nie śledzone pliki
• git stash -p (--patch) -u (--include-untracked): invalid polecenie

Obecnie najbardziej rozsądną metodą, aby móc ukryć konkretne śledzone / nie śledzone Pliki, jest:

• tymczasowo Zatwierdź pliki, których nie chcesz ukryć
• Dodaj i schowaj
• Pop tymczasowy commit

Napisałem prosty skrypt tej procedury w odpowiedzi na inne pytanie, i są kroki do wykonania procedury w SourceTree tutaj .

Rozwiązanie

Lokalne zmiany:

• file_A (modified) not staged
• file_B (modified) not staged
• file_C (modified) not staged

Aby utworzyć skrytkę "my_stash" z tylko zmianami na 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}

Wyjaśnienie

1. Dodaj file_C do obszaru postoju
2. Utwórz tymczasowy Schowek o nazwie "temp_stash" i Zachowaj zmiany w pliku_c
3. create the wanted stash ("my_stash") tylko ze zmianami na pliku_c
4. Zastosuj zmiany w "temp_stash" (plik_a i plik_b) na lokalnym kodzie i usuń stash

Możesz użyć Git status pomiędzy krokami, aby zobaczyć, co się dzieje.

Kiedy próbujesz przełączyć się między dwoma gałęziami, pojawia się taka sytuacja.

Spróbuj dodać pliki używając "git add filepath".

Później wykonaj tę linię

git stash --keep-index

Aby ukryć pojedynczy plik użyj git stash --patch [file].

To spowoduje: Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?. Po prostu wpisz a (Schowaj ten przystojniak i wszystkie późniejsze przystojniaki w pliku) i będzie dobrze.

Podobna sytuacja. Popełnił i zdał sobie sprawę, że nie jest w porządku.

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

# 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

W tej sytuacji ja git add -p (interaktywny), git commit -m blah i wtedy schowam to, co pozostało, jeśli to konieczne.

Nie wiem jak to zrobić w wierszu poleceń, tylko używając SourceTree. Powiedzmy, że zmieniłeś plik A i masz dwie zmiany w pliku B. Jeśli chcesz ukryć tylko drugi fragment w pliku B i pozostawić wszystko inne nietknięte, zrób to:

1. Stage everything
2. Wykonaj zmiany w kopii roboczej, które cofają wszystkie zmiany w pliku A. (np. Uruchom zewnętrzne narzędzie diff i dopasuj pliki.)
3. spraw, aby plik B wyglądał tak, jakby zastosowano do niego tylko drugą zmianę. (np. uruchomienie zewnętrzne narzędzie diff i cofnij pierwszą zmianę.)
4. Utwórz skrytkę używając opcji "Zachowaj zmiany w poczekalni".
5. Unstage everything
Zrobione!

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)

Jednym ze skomplikowanych sposobów byłoby najpierw popełnić wszystko:

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

Zresetuj z powrotem do oryginalnego commita, ale odeślij Plik z nowego commita:

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

Teraz możesz schować plik:

git stash

Czyszczenie poprzez zapisanie zatwierdzonej zawartości w systemie plików podczas resetowania z powrotem do oryginalnego zatwierdzenia:

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

Nie znalazłem odpowiedzi na to, czego potrzebowałem, a to jest tak proste jak:

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

To przechowuje dokładnie jeden plik.

Szybka Odpowiedź

Aby przywrócić określony zmieniony plik w git, możesz wykonać następującą linię:

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

Oto przykład:

git checkout master -- battery_monitoring/msg_passing.py