Как я могу сохранить только один из нескольких измененных файлов в моей ветке?

Отказ от ответственности : следующий ответ для 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 stash save -p "my commit message". Таким образом, вы можете выбрать, какие блоки должны быть добавлены в тайник, а также целые файлы.

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

   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 stash, неудивительно, чтосо всем рабочим каталогом,

На самом деле, начиная с Git 2.13 (Q2 2017), вы можете хранить отдельные файлы с помощью git stash push:

git stash push [--] [<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 «s ответ (upvoted, ноябрь 2011) предлагает более практичное решение, основанное на
git add+git stash --keep-index .
Иди посмотри и провозгласи его ответ, который должен быть официальным (вместо моего).

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

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

(Оригинальный ответ, июнь 2010 г .: тайник)

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

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

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

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

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

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

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

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

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

Когда 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

Используйте git stash push, как это:

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

Например:

git stash push -- my/file.sh

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

Допустим, у вас есть 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

И вы сделали! НТН.

Еще один способ сделать это:

# 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 как «где-то» (и в результате есть один дополнительный шаг в конце: удаление канавок, которые вы поместили в 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 -- filename.ext

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

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

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

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

git stash push "filename"

или с дополнительным сообщением

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

Сохраните следующий код в файл, например, с именем 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 (вероятно, схожие инструменты) вместо copy:

• tar cvf /tmp/stash.tar path / to / some / путь к файлу / 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, где вы можете просто щелкнуть файлы (или даже отдельные строки), которые вы хотите добавить. После добавления просто передайте их во временную фиксацию. Далее, установите флажок, чтобы добавить все изменения, затем нажмите stash, чтобы спрятать все. С сохраненными изменениями в пути, взгляните на ваш список коммитов и запишите хеш для коммита перед вашим временным коммитом, затем запустите '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): неверная команда

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

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

Я написал простой скрипт для этой процедуры в ответ на другой вопрос , и здесь есть шаги для выполнения процедуры в 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. Выполнено!

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)

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

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

Это прячет ровно один файл.

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

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

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

Вот фактический пример:

git checkout master -- battery_monitoring/msg_passing.py

Если вы хотите сохранить некоторые измененные файлы, просто

Добавьте файлы, которые вы не хотите хранить, в рабочей области , затем выполнитеgit stash save --keep-index

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