git stash push -p -m "my commit message"

-p давайте выберем фрагменты, которые нужно спрятать; также могут быть выбраны целые файлы.

Вам будет предложено выполнить несколько действий для каждого фрагмента:

   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

Заявление об ограничении ответственности: следующий ответ предназначен для git до git 2.13. Для git 2.13 и более поздних версий ознакомьтесь с другим ответом ниже.

Предупреждение

Как отмечено в комментариях, это помещает все в тайник, как постановочное, так и неустановленное. --Keep-index просто оставляет индекс в покое после завершения хранения. Это может вызвать конфликты слияния, когда вы позже откроете тайник.

Это сохранит все, что вы ранее не добавляли. Просто git add то, что вы хотите сохранить, а затем запустите.

git stash --keep-index

Например, если вы хотите разбить старую фиксацию на несколько наборов изменений, вы можете использовать эту процедуру:

1. git rebase -i <last good commit>
2. Отметьте некоторые изменения как edit.
3. git reset HEAD^
4. git add <files you want to keep in this change>
5. git stash --keep-index
6. При необходимости исправьте ситуацию. Не забывайте git add любые изменения.
7. git commit
8. git stash pop
9. При необходимости повторите, начиная с №5.
10. git rebase --continue

Начиная с Git 2.13 (второй квартал 2017 г.), вы можете хранить отдельные файлы с помощью _ 1_:

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

Когда pathspec присвоено 'git stash push', новый тайник записывает измененные состояния только для файлов, соответствующих указанному пути. См. Изменения тайника для определенных файлов, чтобы узнать больше.

Упрощенный пример:

 git stash push path/to/file

Тестовый пример для этой функции показывает еще несколько вариантов выключены:

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

Первоначальный ответ (ниже, июнь 2010 г.) касался ручного выбора того, что вы хотите спрятать.

Комментарии Casebash:

Это (исходное решение stash --patch) приятно, но я часто изменял много файлов, поэтому использование патча раздражает

ответ от bukzor (проголосовано за ноябрь 2011 г.) предлагает более практичное решение, основанное на
git add + git stash --keep-index.
Посмотрите и проголосуйте за его ответ, который должен быть официальным (вместо этого мой).

Об этом варианте chhh указывает в комментариях на альтернативный рабочий процесс:

вы должны git reset --soft после такого тайника вернуть четкую постановку:
Чтобы вернуться к исходному состоянию, которое является чистой промежуточной областью и только с некоторыми избранными неустановленными модификациями, можно мягко сбросить индекс до получить (не совершая ничего подобного вам - букзор - сделал).

(Исходный ответ июнь 2010 г .: тайник вручную)

Тем не менее, git stash save --patch может позволить вам добиться частичного хранения, которое вам нужно:

С --patch вы можете в интерактивном режиме выбирать блоки из разницы между HEAD и рабочим деревом, которое нужно сохранить.
Запись в тайнике построена так, что ее состояние индекса совпадает с состоянием индекса вашего репозитория и его рабочего дерева содержит только те изменения, которые вы выбрали в интерактивном режиме. Затем выбранные изменения откатываются от вашего рабочего дерева.

Однако это сохранит полный индекс (который может быть не тем, что вам нужно, поскольку он может включать другие уже проиндексированные файлы) и частичное рабочее дерево (которое может выглядеть как то, которое вы хотите спрятать).

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

может быть лучше.

Если --patch не работает, ручной процесс может:

Для одного или нескольких файлов промежуточным решением было бы:

• скопируйте их за пределы репозитория Git
  (на самом деле eleotlecram предлагает интересная альтернатива)
• git stash
• скопируйте их обратно
• git stash # на этот раз сохраняются только те файлы, которые вам нужны
• git stash pop stash@{1} # повторно примените все изменения ваших файлов
• git checkout -- afile # сбросить файл до содержимого HEAD перед любыми локальными изменениями

В конце этого довольно громоздкого процесса у вас останется только один или несколько файлов.

Используйте git stash push, например:

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

Например:

git stash push -- my/file.sh

Это доступно, начиная с Git 2.13, выпущенного весной 2017 года.

Когда git stash -p (или git add -p с stash --keep-index) было бы слишком громоздко, мне было проще использовать diff, checkout и apply:

Чтобы "спрятать" только определенный файл / каталог:

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

Потом потом

git apply stashed.diff

Допустим, у вас есть 3 файла

a.rb
b.rb
c.rb

и вы хотите спрятать только b.rb и c.rb, но не a.rb

ты можешь сделать что-то вроде этого

# 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

Готово! HTH.

Если вы не хотите указывать сообщение с сохраненными изменениями, передайте имя файла после двойного тире.

$ git stash -- filename.ext

Если это не отслеживаемый / новый файл, вам сначала нужно его обработать.

Этот метод работает в версиях git 2.13+.

Другой способ сделать это:

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

Я придумал это после того, как (еще раз) зашел на эту страницу, и мне не понравились первые два ответа (первый ответ просто не отвечает на вопрос, и мне не очень понравилось работать в интерактивном режиме -p).

Идея такая же, как и в случае с предложением @VonC использовать файлы вне репозитория: вы где-то сохраняете нужные изменения, удаляете ненужные изменения в своем тайнике, а затем повторно применяете изменения, которые вы убрали с пути. Тем не менее, я использовал git stash как «где-то» (и в результате есть один дополнительный шаг в конце: удаление изменений, которые вы вставляете в тайник, потому что вы их тоже убрали).

Обновление (14.02.2015). Я немного переписал сценарий, чтобы лучше справляться с конфликтами, которые теперь должны быть представлены как несвязанные конфликты, а не как файлы .rej.

Я часто нахожу более интуитивным подход, противоположный подходу @bukzor. То есть провести некоторые изменения, а затем спрятать только эти поэтапные изменения.

К сожалению, git не предлагает git stash --only-index или аналогичный, поэтому я создал для этого скрипт.

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

Вы можете сохранить приведенный выше скрипт как git-stash-index где-нибудь на своем пути, а затем вызвать его как git stash-index

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

Теперь тайник содержит новую запись, которая содержит только внесенные вами изменения, а ваше рабочее дерево по-прежнему содержит любые неустановленные изменения.

В некоторых случаях изменения рабочего дерева могут зависеть от изменений индекса, поэтому, когда вы сохраняете изменения индекса, изменения рабочего дерева конфликтуют. В этом случае вы получите обычные конфликты без объединения, которые можно разрешить с помощью git merge / git mergetool / etc.

Вы можете просто сделать это:

git stash push "filename"

или с необязательным сообщением

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

Поскольку создание веток в Git тривиально, вы можете просто создать временную ветку и проверить в ней отдельные файлы.

Если вы хотите сохранить только некоторые из измененных файлов, просто добавьте другие файлы в Stage, затем выполните git stash push --keep-index

Он сохранит все неустановленные измененные файлы.

Сохраните следующий код в файл, например, с именем stash. Использование stash <filename_regex>. Аргумент - это регулярное выражение для полного пути к файлу. Например, чтобы спрятать a / b / c.txt, stash a/b/c.txt или stash .*/c.txt и т. Д.

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

Код для копирования в файл:

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

На всякий случай вы действительно имеете в виду отменить изменения всякий раз, когда используете git stash (и на самом деле не используете git stash для его временного хранения), в этом случае вы можете использовать

git checkout -- <file>

[ПРИМЕЧАНИЕ]

Этот git stash - всего лишь более быстрая и простая альтернатива ветвлению и работе.

Проблема с "промежуточным" решением VonC по копированию файлов за пределы репозитория Git заключается в том, что вы теряете информацию о пути, что делает копирование группы файлов обратно позже в некоторой степени затруднительным.

А проще использовать tar (вероятно, подойдут аналогичные инструменты) вместо копирования:

• tar cvf /tmp/stash.tar path / to / some / file path / to / some / other / file (... и т. д.)
• git checkout path / to / some / путь к файлу / to / some / other / file
• мерзавец
• tar xvf /tmp/stash.tar
• и т. д. (см. "промежуточное" предложение VonC)

Иногда я вносил несвязанные изменения в свою ветку до того, как зафиксировал их, и я хочу переместить их в другую ветку и зафиксировать отдельно (например, master). Я делаю это:

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

Обратите внимание, что первый stash & stash pop можно исключить, вы можете перенести все свои изменения в ветку master при оформлении заказа, но только если нет конфликтов. Также, если вы создаете новую ветку для частичных изменений, вам понадобится тайник.

Вы можете упростить его, предполагая отсутствие конфликтов и новой ветки:

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

Тайник даже не нужен ...

Это можно легко сделать за 3 шага с помощью SourceTree.

1. Временно зафиксируйте все, что вы не хотите прятать.
2. Git добавляет все остальное, а затем прячет.
3. Удалите временную фиксацию, запустив git reset, выбрав фиксацию перед временной.

Все это можно сделать за считанные секунды в SourceTree, где вы можете просто щелкнуть файлы (или даже отдельные строки), которые хотите добавить. После добавления просто зафиксируйте их во временной фиксации. Затем установите флажок, чтобы добавить все изменения, затем щелкните тайник, чтобы спрятать все. Убрав спрятанные изменения в сторону, взгляните на свой список коммитов и обратите внимание на хэш для фиксации перед временной фиксацией, затем запустите 'git reset hash_b4_temp_commit', что в основном похоже на «выталкивание» фиксации путем сброса вашей ветки на совершить прямо перед этим. Теперь у вас осталось только то, что вы не хотели прятать.

Я бы использовал git stash save --patch. Я не считаю интерактивность раздражающей, потому что во время нее есть опции, позволяющие применить желаемую операцию ко всем файлам.

Каждый ответ здесь такой сложный ...

А как насчет этого «припрятать»:

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

Это, чтобы вернуть изменение файла:

git apply /tmp/stash.patch

Точно такое же поведение, как при сохранении одного файла и его возвращении.

Я просмотрел ответы и комментарии к этой и ряду подобных тем. Имейте в виду, что ни одна из следующих команд не подходит для сохранения каких-либо определенных отслеживаемых / неотслеживаемых файлов:

• git stash -p (--patch): выбрать блоки вручную, исключая неотслеживаемые файлы
• git stash -k (--keep-index): хранить все отслеживаемые / неотслеживаемые файлы и хранить их в рабочем каталоге
• git stash -u (--include-untracked): хранить все отслеживаемые / неотслеживаемые файлы
• git stash -p (--patch) -u (--include-untracked): недопустимая команда

В настоящее время наиболее разумным методом хранения любых отслеживаемых / неотслеживаемых файлов является:

• Временно зафиксируйте файлы, которые вы не хотите хранить
• Добавить и спрятать
• Удалите временную фиксацию

Я написал простой сценарий для этой процедуры в ответ на другой вопрос, и есть шаги для выполнения процедуры в SourceTree здесь.

Решение

Локальные изменения:

• file_A (изменено) не поставлено
• file_B (изменено) не поставлено
• file_C (изменено) не поставлено

Чтобы создать тайник my_stash только с изменениями в 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}

Выполнено.

Объяснение

1. добавить file_C в область подготовки
2. создайте временный тайник с именем «temp_stash» и сохраните изменения в file_C
3. создать желаемый тайник ("my_stash") только с изменениями в file_C
4. примените изменения в "temp_stash" (file_A и file_B) в вашем локальном коде и удалите тайник

Вы можете использовать git status между шагами, чтобы увидеть, что происходит.

Такая ситуация возникает при попытке переключиться между двумя ветвями.

Попробуйте добавить файлы с помощью «git add filepath».

Позже выполните эту строку

git stash --keep-index

Чтобы спрятать один файл, используйте git stash --patch [file].

Появится запрос: Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]? ?. Просто введите a (спрячьте этот кусок и все последующие фрагменты в файл), и все в порядке.

Аналогичная ситуация. Сделал коммит и понял, что это не нормально.

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

В этой ситуации я git add -p (интерактивно), git commit -m blah, а затем прячу то, что осталось, если необходимо.

Я не знаю, как это сделать в командной строке, только с помощью SourceTree. Допустим, вы изменили файл A и у вас есть два фрагмента изменений в файле B. Если вы хотите спрятать только второй фрагмент в файле B и оставить все остальное нетронутым, сделайте следующее:

1. Сценическое все
2. Внесите изменения в вашу рабочую копию, которые отменит все изменения в файле A. (например, запустите внешний инструмент сравнения и сопоставьте файлы.)
3. Сделайте так, чтобы файл B выглядел так, как будто к нему применяется только второе изменение. (например, запустить внешний инструмент сравнения и отменить первое изменение.)
4. Создайте тайник, используя «Сохранять поэтапные изменения».
5. Убрать все на сцену
6. Выполнено!

Для пользователей VS Code. Кнопка тайника для группы Изменения в представлении боковой панели Git сохранит только файлы в группе. Поэтому, если вы переместите некоторые файлы из этой группы, вы можете спрятать оставшиеся файлы. Единственный известный мне способ переместить некоторые файлы оттуда без отмены изменений - это выполнить их. Так:

1. Подготовьте файлы, которые вы не хотите прятать
2. Нажмите кнопку тайника в заголовке группы Изменения.
3. Отключите файлы, которые вы переместили с пути

Один из сложных способов - сначала зафиксировать все:

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

Вернитесь к исходной фиксации, но проверьте the_one_file из новой фиксации:

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

Теперь вы можете спрятать the_one_file:

git stash

Очистка путем сохранения зафиксированного содержимого в файловой системе с возвратом к исходной фиксации:

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

Ага, несколько неловко ...

Я не нашел того, что мне было нужно, и это очень просто:

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

Это хранит ровно один файл.

Я тоже хотел сделать то же самое, но когда я подумал об этом еще раз, я понял, что на самом деле я не хочу тратить время на все хлопоты, чтобы просто сохранить один файл. Мне было бы намного проще скопировать его в другое место и добавить несколько комментариев, чтобы напомнить мне, почему я сохранил его там.

Не поймите меня неправильно: есть масса причин, по которым вы хотели бы просто спрятать один файл, и в целом использование программного обеспечения для контроля версий всегда является лучшим методом. Но все же убедитесь, что вы не зря теряете время. В моем случае я просто хотел сохранить файл и отменить все другие изменения, а затем вставить его после перехода на новую ветку. Итак, cp/mv работал достаточно хорошо.

Быстрый ответ

Чтобы вернуть конкретный измененный файл в git, вы можете сделать следующую строку:

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

Вот реальный пример:

git checkout master -- battery_monitoring/msg_passing.py

Вы также можете сохранить только один файл, коллекцию файлов или отдельные изменения внутри файлов. Если вы передадите параметр -p (или --patch) в git stash, он будет перебирать каждый измененный «кусок» в вашей рабочей копии и спрашивать, хотите ли вы его спрятать:

$ git stash -p

нажмите одну из клавиш, как показано ниже, и она запустит эту команду

Command   Description 
y         stash this hunk  
/         search for a hunk by regex .  
?         help .   
n         don't stash this hunk .    
q         quit (any hunks that have already been selected will be stashed) .   
s         split this hunk into smaller hunks