仅在 git 中暂存分阶段的更改 - 有可能吗？

Question

有没有一种方法可以只存储我的分阶段更改？我遇到问题的场景是我在给定时间处理了几个错误，并且有几个未分阶段的更改。我希望能够单独暂存这些文件，创建我的 .patch 文件，然后将它们隐藏起来，直到代码获得批准。这样，当它被批准后，我可以隐藏我的整个（当前）会话，弹出该错误并推送代码。

我是不是走错了路？我是否误解了 git 如何以其他方式工作以简化我的流程？

Answer 1

是的，DOUBLE STASH

是可能的

1. 暂存所有需要暂存的文件。
2. 运行git stash --keep-index。此命令将使用您的 ALL 更改（已暂存和未暂存）创建一个暂存区，但会将暂存的更改保留在您的工作目录中（仍处于暂存状态）。李>
3. 运行git stash push -m "good stash"
4. 现在您的"good stash" 有只有暂存文件。

现在，如果您在存储之前需要未暂存的文件，只需应用第一个存储（使用 --keep-index 创建的文件），现在您可以删除存储到 "good stash" 的文件。

享受

Answer 2

使用最新的 git，您可以使用 --patch 选项

git stash push --patch   # since 2.14.6

git stash save --patch   # for older git versions

并且 git 会询问您文件中的每个更改是否添加到存储中。
你只需回答y 或n

UPD
DOUBLE STASH 的别名：

git config --global alias.stash-staged '!bash -c "git stash --keep-index; git stash push -m "staged" --keep-index; git stash pop stash@{1}"'

现在您可以暂存文件，然后运行 ​​git stash-staged。
结果您的暂存文件将保存到存储中。

如果您不想保留暂存文件并将它们移动到存储中。然后你可以添加另一个别名并运行git move-staged:

git config --global alias.move-staged '!bash -c "git stash-staged;git commit -m "temp"; git stash; git reset --hard HEAD^; git stash pop"'

Answer 3

TL;DR 只需为您的 git <pathspec> 参数添加 -- $(git diff --staged --name-only)

这是一个简单的单行：

git stash -- $(git diff --staged --name-only)

然后简单地添加一条消息：

git stash push -m "My work in progress" -- $(git diff --staged --name-only)

在 v2.17.1 和 v2.21.0.windows.1

上测试

限制：

• 请注意，如果您没有暂存文件，这将隐藏所有内容。
• 此外，如果您有一个仅部分暂存的文件（即只有一些更改的行被暂存，而其他一些更改的行没有），那么 整个文件将被隐藏（包括未暂存的行）。

Answer 4

我制作了一个脚本，它只存储当前上演的内容并保留其他所有内容。当我开始进行太多不相关的更改时，这真是太棒了。只需暂存与所需提交无关的内容并将其隐藏即可。

（感谢 Bartłomiej 的起点）

#!/bin/bash

#Stash everything temporarily.  Keep staged files, discard everything else after stashing.
git stash --keep-index

#Stash everything that remains (only the staged files should remain)  This is the stash we want to keep, so give it a name.
git stash save "$1"

#Apply the original stash to get us back to where we started.
git stash apply stash@{1}

#Create a temporary patch to reverse the originally staged changes and apply it
git stash show -p | git apply -R

#Delete the temporary stash
git stash drop stash@{1}

Answer 5

为了完成同样的事情......

1. 仅暂存您要处理的文件。
2. git commit -m 'temp'
3. git add .
4. git stash
5. git reset HEAD~1

轰隆隆。您不想要的文件被隐藏起来。你想要的文件都准备好了。

Answer 6

在 Git 中仅存储索引（分阶段更改）比应有的困难。我发现@Joe 的answer 运行良好，并将它的一个小变体变成了这个别名：

stash-index = "!f() { \
  ! git diff --cached --exit-code --quiet && \
  git stash push --quiet --keep-index -m \"temp for stash-index\" && \
  git stash push \"$@\" && \
  git stash pop --quiet stash@{1} && \
  git stash show -p | git apply -R; }; f"

它：

1. 验证是否存在实际分阶段的更改（git diff --cached --exit-code 如果有，则返回非零状态）。 HT：@nandilugio

2. 它将分阶段和非分阶段的更改推送到一个临时存储区，只留下分阶段的更改。

3. 然后它将分阶段的更改推送到存储区，这是我们想要保留的存储区。传递给别名的参数，例如 --message "whatever" 将被添加到此存储命令中。

4. 它会弹出临时存储以恢复原始状态并删除临时存储，然后

5. 最后通过反向补丁应用程序从工作目录中“删除”隐藏的更改。

有关仅存储未暂存更改（别名stash-working）的相反问题，请参阅this answer。

Answer 7

在这种情况下，我更喜欢为每个问题创建新的分支。我使用前缀 temp/，所以我知道以后可以删除这些分支。

git checkout -b temp/bug1

暂存修复 bug1 的文件并提交。

git checkout -b temp/bug2

然后，您可以根据需要从各个分支中挑选提交并提交拉取请求。

Answer 8

在 Git 2.35（2022 年第一季度）中，“git stash”^(man) 学习了 --staged 选项来隐藏已添加到索引中的内容（仅此而已）。

所以现在正式支持（8 年后）。

参见commit a8a6e06（2021 年 10 月 28 日）和 commit 41a28eb（2021 年 10 月 18 日）Sergey Organov (sorganov)。
^{（由 Junio C Hamano -- gitster -- 合并于 commit 44ac8fd，2021 年 11 月 29 日）支持>}

stash: 为 'push' 和 'save' 实现 '--staged' 选项

^{签字人：Sergey Organov}

仅存储暂存的更改。

此模式允许轻松隐藏以供以后重用一些与当前正在进行的工作无关的更改。

与'stash push --patch'不同，--staged 支持使用任何工具来选择要隐藏的更改，包括但不限于'git add --interactive'^(man) .

git stash 现在包含在其man page 中：

'git stash' [push [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-q|--quiet]

git stash 现在包含在其man page 中：

save [-p|--patch] [-S|--staged] [-k|--[no-]keep-index] [-u|--include-untracked] [-a|--all] [-q|--quiet] [<message>]

git stash 现在包含在其man page 中：

-S

--staged

此选项仅对push 和save 命令有效。

仅存储当前暂存的更改。这类似于 基本git commit，除了状态被提交到存储区 当前分支的。

--patch 选项优先于这个选项。

git stash 现在包含在其man page 中：

Saving unrelated changes for future use

当你正处于巨大的变化之中，你会发现一些 您不想忘记修复的无关问题，您可以执行 更改，暂存它们，并使用git stash push --staged 存储它们 供将来使用。
这类似于提交分阶段的更改， 只有提交最终会在 stash 中，而不是在当前分支中。

----------------------------------------------------------------
# ... hack hack hack ...
$ git add --patch foo           # add unrelated changes to the index
$ git stash push --staged       # save these changes to the stash
# ... hack hack hack, finish curent changes ...
$ git commit -m 'Massive'       # commit fully tested changes
$ git switch fixup-branch       # switch to another branch
$ git stash pop                 # to finish work on the saved changes
----------------------------------------------------------------

Answer 9

您为什么不提交某个错误的更改并从该提交及其前身创建一个补丁？

# hackhackhack, fix two unrelated bugs
git add -p                   # add hunks of first bug
git commit -m 'fix bug #123' # create commit #1
git add -p                   # add hunks of second bug
git commit -m 'fix bug #321' # create commit #2

然后，要创建适当的补丁，请使用git format-patch：

git format-patch HEAD^^

这将创建两个文件：0001-fix-bug-123.patch 和 0002-fix-bug-321.patch

或者您可以为每个错误创建单独的分支，这样您就可以单独合并或重新定位错误修复，如果它们不起作用，甚至删除它们。

Answer 10

git stash --keep-index 是一个很好的解决方案...除了它在已删除的路径上无法正常工作，这已在 Git 2.23（2019 年第三季度）中修复

参见Thomas Gummerer (tgummerer)commit b932f6a（2019 年 7 月 16 日）。
^{（由 Junio C Hamano -- gitster -- 合并于 commit f8aee85，2019 年 7 月 25 日）}

stash：修复使用--keep-index 处理删除的文件

git stash push --keep-index 应该保留所有更改 已添加到索引中，无论是在索引中还是在磁盘上。

目前，当从索引中删除文件时，这不会正确运行。
不是将其保留在磁盘上删除，而是 **--keep-index 当前恢复文件。* *

通过在无覆盖模式下使用“git checkout”来修复该行为 可以忠实还原索引和工作树。
这也简化了代码。

请注意，如果未跟踪的文件与已在索引中删除的文件同名，这将覆盖未跟踪的文件。

Answer 11

另一种方法是使用您不想隐藏的文件创建一个临时提交，然后隐藏剩余的文件并轻轻删除最后一次提交，保持文件完整：

git add *files that you don't want to be stashed*
git commit -m "temp"
git stash --include-untracked
git reset --soft HEAD~1

这样你只触摸你想被触摸的文件。

注意，这里使用“--include-untracked”来存储新文件（这可能是您真正想要的）。

Answer 12

是否绝对有必要同时处理多个错误？ “一次”是指“同时为多个错误编辑文件”。因为除非您绝对需要，否则我一次只会在您的环境中处理一个错误。这样你就可以使用本地分支和变基，我发现这比管理复杂的存储/阶段要容易得多。

假设 master 在提交 B。现在处理错误 #1。

git checkout -b bug1

现在您在分支 bug1 上。进行一些更改，提交，等待代码审查。这是本地的，因此您不会影响其他任何人，并且从 git diffs 制作补丁应该很容易。

A-B < master
   \
    C < bug1

现在您正在处理 bug2。使用git checkout master 返回返回以掌握。创建一个新分支，git checkout -b bug2。进行更改、提交、等待代码审查。

    D < bug2
   /
A-B < master
   \
    C < bug1

让我们假设其他人在您等待审核时在 master 上提交了 E & F。

    D < bug2
   /
A-B-E-F < master
   \
    C < bug1

当您的代码获得批准后，您可以通过以下步骤将其变基为 master：

git checkout bug1
git rebase master
git checkout master
git merge bug1

这将导致以下结果：

    D < bug2
   /
A-B-E-F-C' < master, bug1

然后你可以推送、删除你的本地 bug1 分支，然后你就可以走了。在您的工作空间中一次出现一个错误，但通过使用本地分支，您的存储库可以处理多个错误。这避免了复杂的舞台/隐藏舞蹈。

在cmets中回答ctote的问题：

好吧，您可以为每个错误返回隐藏，一次只处理一个错误。至少可以为您节省分期问题。但是试过这个，我个人觉得很麻烦。在 git 日志图中，Stash 有点混乱。更重要的是，如果你把事情搞砸了，你就无法恢复。如果你有一个脏的工作目录并且你弹出一个存储，你不能“撤消”那个弹出。搞砸已经存在的提交要困难得多。

所以git rebase -i。

当您将一个分支变基到另一个分支时，您可以交互地进行（-i 标志）。执行此操作时，您可以选择要对每个提交执行的操作。 Pro Git 是一本很棒的书，它也是 HTML 格式的在线书籍，并且有一个很好的关于 rebase 和 squashing 的部分：

http://git-scm.com/book/ch6-4.html

为方便起见，我将逐字窃取他们的示例。假设您有以下提交历史记录，并且您想将 bug1 变基并压缩到 master 上：

    F < bug2
   /
A-B-G-H < master
   \
    C-D-E < bug1

这是您在输入 git rebase -i master bug1 时将看到的内容

pick f7f3f6d changed my name a bit
pick 310154e updated README formatting and added blame
pick a5f4a0d added cat-file
#
# Commands:
#  p, pick = use commit
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit
#
# If you remove a line here THAT COMMIT WILL BE LOST.
# However, if you remove everything, the rebase will be aborted.
#

要将分支的所有提交压缩为单个提交，请将第一个提交保留为“pick”，并将所有后续“pick”条目替换为“squash”或简单的“s”。您也将有机会更改提交消息。

pick f7f3f6d changed my name a bit
s 310154e updated README formatting and added blame
s a5f4a0d added cat-file
#
# Commands:
#  p, pick = use commit
#  e, edit = use commit, but stop for amending
#  s, squash = use commit, but meld into previous commit

所以，是的，squashing 有点痛苦，但我仍然会推荐它而不是大量使用 stash。

Answer 13

在您对 Mike Monkiewicz 的回答中，我建议使用更简单的模型：使用常规开发分支，但使用合并的 squash 选项在您的主分支中获得单个提交：

git checkout -b bug1    # create the development branch
* hack hack hack *      # do some work
git commit
* hack hack hack *
git commit
* hack hack hack *
git commit
* hack hack hack *
git commit
git checkout master     # go back to the master branch
git merge --squash bug1 # merge the work back
git commit              # commit the merge (don't forget
                        #    to change the default commit message)
git branch -D bug1      # remove the development branch

这个过程的好处是可以使用正常的git工作流程。

Answer 14

要删除意外更改，尤其是删除多个文件，请执行以下操作：

git add <stuff to keep> && git stash --keep-index && git stash drop

换句话说，把垃圾藏起来，把它和藏起来的东西一起扔掉。

在 git 版本 2.17.1 中测试

Answer 15

我还没有看到这个不需要使用git stash 的解决方案：

您甚至根本不需要使用git stash。您可以使用专门的分支 as covered here 来解决这个问题（分支很便宜）。

确实，您可以使用一些可以捆绑到一个 git 别名中的连续命令来单独隔离非和暂存更改：

创建并切换到一个新分支，您将在其中分别提交暂存和未暂存的更改：see here

在任何时候，您都可以git cherry-pick -e 从创建的分支提交一次，以将其应用到您想要的位置（-e 更改其提交消息）。

当你不再需要它时，你可以删除这个“stash 分支”。您可能必须使用-D 选项来强制删除（而不是-d 普通选项），因为所述分支未合并，git 可能会认为如果您删除它可能会丢失数据。如果您没有在删除之前对其进行精心挑选的提交，那是正确的：

git branch -D separated-stashes

您还可以为您的 ~/.gitconfig 添加别名以自动执行此行为：

git config --global alias.bratisla '!git switch -c separated-stashes; git commit -m "staged changes"; git add -u; git commit -m "unstaged changes"; git switch -' # why this name ? : youtu.be/LpE1bJp8-4w

before "stashing"
after "stashing"

---

---

当然，你也可以使用two consecutive stashes达到同样的效果

正如其他答案中所述，您有一些方法可以使用 git stash (-k|--keep-index) 与其他命令相结合，仅存储未暂存或仅暂存的更改。

我个人觉得-k 选项非常令人困惑，因为它隐藏了所有内容，但将分段更改保持在分段状态（这解释了为什么“--keep-index”）。而存储某些东西通常会将其移动到存储条目。使用 -k 时，未暂存的更改会正常隐藏，但暂存的更改只会复制到同一个隐藏条目。

---

第 0 步：您的 git status 中有两件事：一个包含暂存更改的文件，另一个包含未暂存更改的文件。

第 1 步：存储未分级的 + 分级更改，但将分级更改保留在索引中：

git stash -k -m "all changes"

-m "..." 部分是可选的，git stash -k 实际上是git stash push -k 的别名（它不会远程推送任何内容，顺便说一句，别担心）它接受-m 选项来标记您的存储条目以清楚起见（像提交消息或标签，但用于存储条目）。它是已弃用的git stash save 的更新版本。

---

第 1 步之二（可选）：

git stash

存储分阶段的更改（仍在索引中）。 此步骤对于以下内容不是必需的，但表明您可以根据需要仅将暂存的更改放入存储条目中。 如果您使用此行，则必须先git stash (pop|apply) && git add -u，然后才能继续第 2 步。

---

第 2 步：

git commit -m "staged changes"

提交仅包含步骤 0 中的暂存更改，它包含与步骤 1bis 中的隐藏条目相同的内容。

---

第 3 步：

git stash (pop|apply)

从第 1 步恢复存储。 请注意，此存储条目包含所有内容，但由于您已提交分阶段更改，此存储将仅添加步骤 0 中的未分阶段更改。

nb：这里的“restore”并不意味着“git restore”，这是一个不同的命令。

---

第四步：

git add -u

将弹出的存储内容添加到索引中

---

第 5 步：

git commit -m "unstaged changes"

这里的“Unstaged”，与第2步和第3步的cmets中的“staged”一样，指的是第0步。您实际上是在暂存并提交从第0步开始的“暂存更改”。

---

完成！ 您现在有两个单独的提交，其中包含来自步骤 0 的（未）暂存更改。 您可能想要修改/重新设置它们以进行其他更改或重命名/删除/压缩它们。 根据您对 stash 堆栈所做的操作（pop 或 apply），您可能还需要 git stash (drop|clear) 它。您可以看到您使用git stash (list|show) 隐藏条目

Answer 16

TL;DR; git stash-staged

创建别名后：

git config --global alias.stash-staged '!bash -c "git stash -- \$(git diff --staged --name-only)"'

这里git diff返回--staged文件列表--name-only
然后我们将这个列表作为pathspec 传递给git stash commad。

来自man git stash：

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

<pathspec>...
   The new stash entry records the modified states only for the files
   that match the pathspec. The index entries and working tree
   files are then rolled back to the state in HEAD only for these
   files, too, leaving files that do not match the pathspec intact.