如何仅存储已更改的多个文件中的一个文件？

Question

如何在我的分支上仅存储多个更改的文件之一？

Answer 1

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

Answer 2

免责声明：以下答案适用于 git 2.13 之前的 git。对于 git 2.13 及更高版本，请查看下面的另一个答案。

---

警告

正如评论中所指出的，这会将所有内容放入存储中，包括暂存的和未暂存的。 --keep-index 在存储完成后只保留索引。当您稍后弹出存储时，这可能会导致合并冲突。

---

这将隐藏您之前未添加的所有内容。只需git add你想要保留的东西，然后运行它。

git stash --keep-index

例如，如果您想将旧提交拆分为多个变更集，可以使用以下过程：

1. git rebase -i
2. 将某些更改标记为edit.
3. git reset HEAD^
4. git add <您想要在此更改中保留的文件>
5. git stash --keep-index
6. 根据需要修复问题。不要忘记 git add 任何更改。
7. git commit
8. git stash pop
9. 根据需要从 #5 开始重复。
10. git rebase --继续

Answer 3

从 Git 2.13（2017 年第 2 季度）开始，您可以使用 git 存储推送：

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

当pathspec被赋予'git stash push'时，新的stash仅记录与pathspec匹配的文件的修改状态
有关详细信息，请参阅“存储对特定文件的更改”。

简化示例：

 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 年 6 月）是关于手动选择您想要隐藏的内容。

Casebash 评论：

这个（stash --patch原始解决方案）很好，但我经常修改很多文件，所以使用补丁很烦人

bukzor 的答案（已投票，2011 年 11 月）提出了一个更实用的解决方案，基于上
git add + git stash --keep-index。
去看看并投票他的答案，这应该是官方的答案（而不是我的）。

关于该选项， chhh 在评论中指出了替代工作流程：

你应该在这样的存储之后“git reset --soft”来恢复清晰的暂存：
为了达到原始状态 - 这是一个清晰的暂存区域，并且只有一些选择的未暂存修改，可以轻柔地重置索引以获取（无需像您 - bukzor - 那样提交任何内容）。

---

（原始答案 2010 年 6 月：手动存储）

然而，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 内容

在这个相当繁琐的过程结束时，您将只得到隐藏一个或多个文件。

---

正如 mirekphd 在 评论：

如果有一些未跟踪的文件，git stash push --include-untracked 也会包含这些文件。

Answer 4

使用git stash push，如下所示：

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

例如：

git stash push -- my/file.sh

---

此功能自 2017 年春季发布的 Git 2.13 起可用。

Answer 5

当 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

Answer 6

如果您不想指定包含隐藏更改的消息，请在双破折号后传递文件名。

$ git stash -- filename.ext

如果它是未跟踪/新文件，您必须先暂存它。

此方法适用于 git 版本 2.13+

Answer 7

假设您有 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。

Answer 8

如果您只想存储一些已更改的文件，只需在Stage中添加其他文件，然后执行git stash push --keep-index

它将存储所有 >取消暂存更改的文件

Answer 9

另一种方法是：

# 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 作为“某处”（因此，最后有一个额外的步骤：删除您放入存储中的更改，因为您也将它们移开了）。

Answer 10

您可以简单地执行此操作：

git stash push "filename"

或使用可选消息

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

Answer 11

更新（2/14/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 来解决。

Answer 12

由于在 Git 中创建分支很简单，您只需创建一个临时分支并将各个文件签入其中即可。

Answer 13

以防万一您实际上是在使用 git stash 时放弃更改（并且不真正使用 git stash 暂时存储它），在这种情况下您可以使用

git checkout -- <file>

[< strong>注意]

git stash 只是分支和执行操作的更快、更简单的替代方案。

Answer 14

将以下代码保存到文件中，例如，名为 stash。用法是stash。参数是文件完整路径的正则表达式。例如，要存储 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
    }
  }
}

Answer 15

VonC 将文件复制到 Git 存储库外部的“中间”解决方案的问题是，您会丢失路径信息，这使得稍后将一堆文件复制回来会有些麻烦。

A 发现使用 tar （类似的工具可能会这样做）而不是复制更容易：

• tar cvf /tmp/stash.tar path/to/some/file path/to/some/other/file (... etc.)
• git checkout path/to/some/file path/to/some/other/file
• git stash
• tar xvf /tmp/stash.tar
• 等（参见 VonC 的“中间”建议）

Answer 16

我会使用 git stash save --patch 。我不认为交互性很烦人，因为其中有一些选项可以将所需的操作应用于整个文件。

Answer 17

目前（2024 年），Git 使用新的 --staged 选项提供了一种更简单的方法来实现此目的：

git add <some-files>                  # pick (stage) the files to stash
git stash save --staged 'my stash'    # stash only staged

令我惊讶的是，在所有答案中没有人提供最新 Git 版本的解决方案（>= 2.35）了解如何仅暂存许多未暂存更改中的特定文件。

Answer 18

有时，在提交之前，我在分支上进行了不相关的更改，并且我想将其移动到另一个分支并单独提交（例如 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>...

甚至不需要存储......

Answer 19

使用 SourceTree 只需 3 个步骤即可轻松完成此操作。

1. 暂时提交您不想隐藏的所有内容。
2. Git 添加其他所有内容，然后将其隐藏。
3. 通过运行 git reset 弹出临时提交，将目标定位在临时提交之前。

这一切都可以在 SourceTree 中在几秒钟内完成，您只需单击要添加的文件（甚至单独的行）即可。添加后，只需将它们提交到临时提交即可。接下来，单击复选框添加所有更改，然后单击隐藏以隐藏所有内容。将隐藏的更改移开后，浏览一下提交列表并记下临时提交之前提交的哈希值，然后运行“git reset hash_b4_temp_commit”，这基本上就像通过将分支重置为“弹出”提交一样在它之前提交。现在，你只剩下那些你不想藏起来的东西了。

Answer 20

这里的每个答案都如此复杂......

这个“隐藏”怎么样：

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

这将文件更改弹出：

git apply /tmp/stash.patch

与隐藏一个文件并将其弹出回来的行为完全相同。

Answer 21

我已经查看了此主题以及许多类似主题的答案和评论。请注意，以下命令都不正确，无法存储任何特定的跟踪/未跟踪文件：

• git stash -p (--patch): select手动汉克斯，排除未跟踪的文件
• git stash -k (--keep-index)：存储所有跟踪/未跟踪的文件并将它们保存在工作目录
• git stash -u (--include- untracked): stash 所有跟踪/未跟踪的文件
• git stash -p (--patch) -u (--include-untracked): invalid command

目前最合理的方法存储任何特定的跟踪/未跟踪文件的方法是：

• 临时提交您不想存储的文件
• 添加并存储
• 弹出临时提交

< strong>我在回答另一个问题时为此过程编写了一个简单的脚本，并且有步骤在此处执行 SourceTree 中的过程。

Answer 22

当您尝试在两个分支之间切换时，就会发生这种情况。

尝试使用“git add filepath”添加文件。

稍后执行这一行

git stash --keep-index

Answer 23

解决方案

本地更改：

• file_A（已修改）未暂存
• file_B（已修改）未暂存
• file_C（已修改）未暂存

要创建仅包含 file_C 上的更改的存储“my_stash”：

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 来查看发生了什么。

Answer 24

要存储单个文件，请使用 git stash --patch [file] 。

这将提示：Stash this hunk [y,n,q,a,d,j,J,g,/,e,?]？ ？。只需输入 a （将此块和所有后续块存储在文件中）就可以了。

Answer 25

类似的情况。做了承诺并意识到这是不行的。

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

Answer 26

在这种情况下，我git add -p（交互式），git commit -m blah，然后在必要时隐藏剩下的内容。

Answer 27

我不知道如何在命令行上执行此操作，只能使用 SourceTree。假设您已更改文件 A，并在文件 B 中有两个更改块。如果您只想将第二个块存储在文件 B 中并保持其他所有内容不变，请执行以下操作：

1. 暂存所有内容
2. 对工作副本执行更改，撤消所有更改文件 A 中的更改。（例如，启动外部 diff 工具并使文件匹配。）
3. 使文件 B 看起来好像只应用了第二次更改。 （例如，启动外部差异工具并撤消第一个更改。）
4. 使用“保留分阶段更改”创建存储。
5. 取消一切
6. 已完成！

Answer 28

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)

Answer 29

我没有找到我需要的答案，这很简单：

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

这仅存储一个文件。

Answer 30

一种复杂的方法是首先提交所有内容：

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^

是的，有点尴尬……