git stash 用法

git stash 用法 目录.png

一、常用git stash命令：

---

1、git stash

能够将所有未提交的修改（工作区和暂存区）保存至堆栈中，用于后续恢复当前工作目录。默认状态，git stash命令只能将已经跟踪和非.gitignore忽略的文件储藏，未跟踪的文件不会被存储。可以将所有未提交的修改（工作区和暂存区的内容，不包括 untracked 文件或目录） 保存至堆栈区，在需要的时候恢复内容，可以是同分支，也可以是不同的分支

2、git stash push -m "save message"

作用等同于git stash，区别是可以加一些注释，方便查找，只有git stash 也要可以的，但查找时不方便识别.

注意：git stash push -m "message" 替代 git stash save "message"

具体原因参考：http://www.softwhy.com/article-8630-1.html

3、git stash list

查看stash了哪些存储，当前stash中的列表内容

4、git stash show

查看堆栈中最新保存的stash和当前目录的差异，显示做了哪些改动，默认show第一个存储，git stash show stash@{1}查看指定的stash和当前目录差异

5、git stash show -p

查看详细的不同，默认显示第一个存储的改动，如果想显示其他存存储，命令：git stash show stash@{1} -p 查看指定的stash的差异内容

6、git stash apply

推荐

将堆栈中的内容应用到当前目录，不同于git stash pop，该命令不会将内容从堆栈中删除，也就说该命令能够将堆栈的内容多次应用到工作目录中，适应于多个分支的情况，默认使用第一个存储,即stash@{0}，如果要使用其他个,比如第二个：git stash apply stash@{1}

7、git stash pop

谨慎操作

命令恢复之前缓存的工作目录，将缓存堆栈中的对应stash删除，并将对应修改应用到当前的工作目录下,默认为第一个stash,即stash@{0}，如果要应用并删除其他stash，命令：git stash pop stash@{$num} ，比如应用并删除第二个：git stash pop stash@{1}

8、git stash drop stash@{num}

丢弃stash@{num}存储，从列表中删除这个存储

9、git stash clear

删除所有缓存的stash

10、git stash branch

# name 新建分支名称
git stash branch <name>

这条命令会根据最近的 stash 创建一个新的分支，然后删除最近的 stash（和 stash pop 一样）。

如果你需要某个 stash，你可以指明 stash id。

git stash branch <name> stash@{1}

当你将 stash 运用到最新版本的分支后发生了冲突时，这条命令会很有用

从最新的stash创建分支。
应用场景：当储藏了部分工作，暂时不去理会，继续在当前分支进行开发，后续想将stash中的内容恢复到当前工作目录时，如果是针对同一个文件的修改（即便不是同行数据），那么可能会发生冲突，恢复失败，这里通过创建新的分支来解决。可以用于解决stash中的内容和当前目录的内容发生冲突的情景。
发生冲突时，需手动解决冲突

11、暂存未跟踪或忽略的文件

默认情况下，git stash会缓存下列文件：

添加到暂存区的修改（staged changes）
Git跟踪的但并未添加到暂存区的修改（unstaged changes）
但不会缓存以下文件：

在工作目录中新的文件（untracked files）
被忽略的文件（ignored files）
git stash ，命令提供了参数用于缓存上面两种类型的文件。使用-u或者--include-untracked可以stash untracked文件。使用-a或者–all命令可以stash当前目录下的所有修改

12、Git-工具-储藏

https://git-scm.com/book/zh/v1/Git-%E5%B7%A5%E5%85%B7-%E5%82%A8%E8%97%8F%EF%BC%88Stashing%EF%BC%89

二、git stash 操作简单理解：

---

1、修改的文件被储存，新增的文件-执行git stash不会被储存

操作：修改README.md文件内容，新增文件test.txt

# 查看状态 ：README.md和test.txt 为红色字体，说明文件还没有添加到暂存区
$ git status
On branch master
Your branch is up to date with 'origin/master'.
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)
        modified:   README.md
Untracked files:
  (use "git add <file>..." to include in what will be committed)
        test.txt
no changes added to commit (use "git add" and/or "git commit -a")

# 执行储存: 发现README.md 修改的内容已经不存在了，而test.txt文件还在，说明test.txt没有被存起来。说白了就是没有在git 版本控制中的文件，是不能被git stash 存起来的
$ git stash save "20191105 保存"
Saved working directory and index state On master: 20191105 保存

#查看储存列表
$ git stash list
stash@{0}: On master: 20191105 保存

#显示做了哪些改动：发现只保存了修改的README.md文件，并没有新增的test.txt文件
$ git stash show
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

# 将文件添加到暂存区
$ git add test.txt

# 查看状态：test.txt字体变成绿色，说明文件已添加到暂存区
$ git status
On branch master
Your branch is up to date with 'origin/master'.
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
        new file:   test.txt

# 执行储存 ：可以看出没有要储存的文件
$ git stash save "20181105 新增文件test"
Saved working directory and index state On master: 20181105 新增文件test

#查看存储区所有储存的列表
$ git stash list
stash@{0}: On master: 20181105 新增文件test
stash@{1}: On master: 20191105 保存

#显示哪些改动：默认为列表最新的（第一个）
$ git stash show stash@{0}
 test.txt | 2 ++
 1 file changed, 2 insertions(+)

#查看状态：发现新增的test.txt文件已找不到(磁盘中也发现不存在了)
$ git status
On branch master
Your branch is up to date with 'origin/master'.
nothing to commit, working tree clean

#从堆栈中回复到当前目录：test.txt字体变成绿色，说明文件已添加到暂存区，本地磁盘中也能看到了test文件
$ git stash apply stash@{0}
On branch master
Your branch is up to date with 'origin/master'.
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
        new file:   test.txt

#查看储存列表：发现新增文件test还是存在的，也就说 git stash apply stash@{0} 命令能够将堆栈的内容多次应用到工作目录中
$ git stash list
stash@{0}: On master: 20181105 新增文件test
stash@{1}: On master: 20191105 保存

注：

1、在git status 那一步很明显可以看出来，我修改了README，添加了新文件test.txt，然后执行了git stash save后，在执行git stash list 可以看到刚才的save是的信息，然后使用git stash show ，只显示了README的改动被存起来了

2、没有在git 版本控制中的文件，是不能被git stash 存起来的

3、git add 只是把文件加到git 版本控制里，并不等于就被stash起来了，git add和git stash 没有必然的关系，但是执行git stash 能正确存储的前提是文件必须在git 版本控制中才行

4、git stash apply stash@{num} 将堆栈中的内容应用到当前目录

2、只stash一部分文件

常规 git stash 的一个限制是它会一下暂存所有的文件。有时，只备份某些文件更为方便，让另外一些与代码库保持一致。一个非常有用的技巧，用来备份部分文件：

1. add 那些你不想备份的文件（例如： git add file1.js, file2.js）
2. 调用 git stash –keep-index。只会备份那些没有被add的文件。
3. 调用 git reset 取消已经add的文件的备份，继续自己的工作

例如：待完善

三、开发常见git stash操作场景

---

git stash的用法:

要达到的目的是：开发如何保证每次commit都是原子性的

开发常见主要场景有：

• 1、修改bug的代码A和新增功能的代码B都在同一个文件，如何做到分两次提交，每次提交的commit只做一件事
• 2、正在开发新接口A，这个时候需要紧急修改bug B，而接口A开发一半还不想提交到远程仓库，这个时候怎么办
• 3、同时开发新接口AB，AB又有很多代码都是在同一个文件中，怎么样子才能做到每个commit都是原子性的

1、修改bug的代码A和新增功能的代码B都在同一个test.java文件，如何做到分两次提交，每次提交的commit只做一件事

方式一：

描述：修改bug的代码A完事后，直接提交，新增功能的代码B写完后直接提交

流程：

#在test.java中 修改bug代码A,修改好后
#添加到暂存区
$ git add .

#将修改的代码保存到本地仓库
$ git commit -m "在test.java中 修改bug代码A"

#提交到远程仓库
$ git push

#在test.java中 新增功能的代码B，新增完后
#添加到暂存区
$ git add .

#将修改的代码保存到本地仓库
$ git commit -m "在test.java中 新增功能代码B"

#提交到远程仓库
$ git push

方式二：

描述：同一个文件中 有 修改bug代码和新增功能代码，保证每次提交只做一件事(修改bug或新增功能)

流程：将 同一个文件修改bug和新增功能 代码 保存到堆栈中 --> 将堆栈中代码恢复到当前工作目录 --> 手动删除文件中新增功能代码 --> 将 修改bug代码 提交到远程仓库 --> 再次将堆栈中代码恢复到当前工作目录 --> 将 新增功能代码 提交到远程仓库

命令：

#将所有未提交的修改（工作区和暂存区）保存至堆栈中，用于后续恢复当前工作目录
git stash push -m "message"
#拉取最新代码
git pull
#将保存至堆栈的内容 恢复到当前工作目录
git stash apply

具体实现：

#将修和新增功能的文件保存到暂存区，让git版本库管理
$ git add .
#查看状态
$ git status

#将 同一个文件修改bug和新增功能 代码 保存到堆栈中
$ git stash push -m "同一个文件修改bug和新增功能 代码 "

#拉取最新代码
git pull

#查看堆栈中保存的列表
$ git stash list
stash@{0}: On master: 同一个文件修改bug和新增功能 代码

#根据堆栈列表序列  将 “同一个文件修改bug和新增功能 代码” 恢复到当前工作目录
$ git stash apply stash@{0}

#注意：此时，手动删除文件中新增功能代码，仅保留修改bug代码(目的：保证每次commit都具有原子性)

#将 修改bug代码 提交到远程仓库
$ git add .
$ git commit -m "修改bug代码提交"
$ git push

#根据堆栈列表序列  再次将 “同一个文件修改bug和新增功能 代码” 恢复到当前工作目录
$ git stash apply stash@{0}

#将 新增功能代码 提交到远程仓库
$ git add .
$ git commit -m "新增功能代码提交"
$ git push

2、正在开发新接口A，这个时候需要紧急修改bug 接口，而接口A开发一半还不想提交到远程仓库，这个时候怎么办

2.1 修改的bug的内容 在不影响新开发接口A的情况，也是不存在冲突的情况

命令：

#将所有未提交的修改（工作区和暂存区）保存至堆栈中，用于后续恢复当前工作目录
git stash push -m "message"
#拉取最新代码
git pull
#将保存至堆栈的内容 恢复到当前工作目录
git stash apply

具体实现：

#将A接口功能未完成代码 添加至暂存区，让git版本库管理
$ git add .

#将(暂存区或工作区)内容保存到堆栈中
$ git stash push -m "A接口功能未完成代码"

#下拉新的代码
$ git pull

#注意：这里是 修改bug代码 的操作

#修改bug完成，添加到暂存区
$ git add .

#提交bug修改代码
$ git commit -m "提交bug修改代码" 

#将修改内容，提交到远程仓库
$ git push

#查看堆栈中保存的列表
$ git stash list
stash@{0}: On master: A接口功能未完成代码

#根据堆栈列表序列  将 “A接口功能未完成代码” 恢复到当前工作目录
$ git stash apply stash@{0}

#继续开发新的接口A的功能代码

#A接口功能开发完成，将A接口功能提交到远程仓库
$ git add .
#提交新开发的接口A
$ git commit -m "提交新开发的接口A" 
#将修改内容，提交到远程仓库
$ git push

2.2 前提：修改的bug的内容 会影响新开发接口A的情况，存在冲突的情况

命令：

#将所有未提交的修改（工作区和暂存区）保存至堆栈中，用于后续恢复当前工作目录
git stash push -m "message"
#拉取最新代码
git pull
#将保存至堆栈的内容 恢复到当前工作目录
git stash apply

具体实现：

#将A接口功能未完成代码 添加至暂存区，让git版本库管理
$ git add .

#将(暂存区或工作区)内容保存到堆栈中
$ git stash push -m "A接口功能未完成代码"

#下拉新的代码
$ git pull

#注意：这里是 修改bug代码 的操作

#修改bug完成，将修改bug代码 提交到远程仓库
$ git add .
$ git commit -m "提交bug修改代码" 
$ git push

#查看堆栈中保存的列表
$ git stash list
stash@{0}: On master: A接口功能未完成代码

#根据堆栈列表序列  将 “A接口功能未完成代码” 恢复到当前工作目录，发现test.txt文件内容有冲突,需要手动解决冲突
$ git stash apply stash@{0}
Auto-merging test.txt
CONFLICT (content): Merge conflict in test.txt

#打开test.txt 文件 查看冲突内容，这时候要手动打开磁盘上文件找到冲突位置解决冲突内容
$ cat test.txt
<<<<<<< Updated upstream
修改bug代码D
=======
新增功能代码A
>>>>>>> Stashed changes

#先冲突解决，再继续开发新的接口A的功能代码

#A接口功能代码开发完成，将A接口功能提交到远程仓库
$ git add .
$ git commit -m "提交新开发的接口A" 
$ git push

3、同时开发新接口AB，AB又有很多代码都是在同一个文件中，怎么样子才能做到每个commit都是原子性的

描述：开发A、B两个新接口，同时开发，开发中有操作有相同的文件，但开发完成后提交时，需要保证每个提交commit都是具有原子性。

流程：开发AB到一半时(或同时完成开发)-->将AB同时保存到堆栈中-->再将AB恢复到当前工作目录(但堆栈中并不删除)-->将B的所有内容删除-->完成A接口的功能开发并提交到远程仓库-->将堆栈中AB再次恢复到当前工作目录-->删除从堆栈中的拿到的A的代码并解决冲突-->再继续开发B接口的功能-->提交B接口的功能到远程仓库

命令：

#将所有未提交的修改（工作区和暂存区）保存至堆栈中，用于后续恢复当前工作目录
git stash push -m "message"
#拉取最新代码
git pull
#将保存至堆栈的内容 恢复到当前工作目录
git stash apply

具体实现：

#将A、B接口功能未开发完成的代码，添加至暂存区(让git版本管理)
$ git add .

# 将A、B接口功能 未完成代码全部保存到堆栈中
$ git stash push -m "A、B接口功能 未完成代码"

#拉取最新代码
git pull

#将堆栈中保存的 "A、B接口功能 未完成代码" 恢复到当前工作目录(注：堆栈中并不删除 “A、B接口功能 未完成代码”)
$ git stash apply

#注意：此时，手动将恢复的B接口功能的所有代码删除，只保留A接口功能代码(目的：每次commit都具有原子性)

#继续开发A接口功能代码，A接口功能代码开发完成，将A接口功能代码全部提交到远程仓库
$ git add .
$ git commit -m "commit：提交完整A接口功能"
$ git push

#将堆栈中保存的 "A、B接口功能 未完成代码" 再次恢复到当前工作目录(注：堆栈中并不删除)，可能会出现冲突，需要手动解决
$ git stash apply

#注意：此时，需手动解决代码的冲突(解决方式：删除所有从堆栈中恢复的A接口功能未完成代码)，只保留B接口功能代码(目的：每次commit都具有原子性)

#继续开发B接口功能代码，B接口功能代码开发完成，将B接口功能代码全部提交到远程仓库
$ git add .
$ git commit -m "commit：提交完整B接口功能"
$ git push

注：
每次commit都具有原子性: 是说每次commit只做一件完整的事情，如，修改一个BUG或是完成一个接口功能开发。切记，不能commit提交一次包含 "新增功能和修改bug"