Git 安装与使用_git 安装及使用

1. Git简介

Git是目前世界上最先进的分布式版本控制系统（没有之一）。

1.1 版本控制

1.1.1 手动版本控制

如果你用Microsoft Word写论文，那你一定有这样的经历：想删除一个段落，又怕将来想恢复找不回来怎么办？有办法，先把当前文件“另存为……”一个新的Word文件，再接着改，改到一定程度，再“另存为……”一个新文件，这样一直改下去，最后你的Word文档变成了这样：

1.1.2 自动版本控制

能记录每次文件的改动：

1.2 Git的诞生

Linus花了两周时间自己用C写了一个分布式版本控制系统，这就是Git！
Git迅速成为最流行的分布式版本控制系统，尤其是2008年，GitHub网站上线了，它为开源项目免费提供Git存储，无数开源项目开始迁移至GitHub，包括jQuery，PHP，Ruby等等

1.3 分布式版本控制

先说集中式版本控制系统，版本库是集中存放在中央服务器的，而干活的时候，用的都是自己的电脑，所以要先从中央服务器取得最新的版本，然后开始干活，干完活了，再把自己的活推送给中央服务器。中央服务器就好比是一个图书馆，你要改一本书，必须先从图书馆借出来，然后回到家自己改，改完了，再放回图书馆。

分布式版本控制系统根本没有“中央服务器”，每个人的电脑上都是一个完整的版本库，这样，你工作的时候，就不需要联网了，因为版本库就在你自己的电脑上。既然每个人电脑上都有一个完整的版本库，那多个人如何协作呢？比方说你在自己电脑上改了文件A，你的同事也在他的电脑上改了文件A，这时，你们俩之间只需把各自的修改推送给对方，就可以互相看到对方的修改了。和集中式版本控制系统相比，分布式版本控制系统的安全性要高很多，因为每个人电脑里都有完整的版本库，某一个人的电脑坏掉了不要紧，随便从其他人那里复制一个就可以了。

2. Git实战

2.1 下载

下载Git 官方地址为：https://git-scm.com/download/win

2.2 安装

接下来就是一直next到安装成功

安装成功之后，右键鼠标会出现Git Bash Here


安装成功！

安装完成后，还需要最后一步设置，在命令行输入：

$ git config --global user.name "Your Name"
$ git config --global user.email "email@example.com"
$ git config --global --get user.name #得到user.name的值
$ git config --global -l #列表参数
1
2
3
4

Git是分布式版本控制系统，所以，每个机器都必须自报家门：你的名字和Email地址

2.3 创建版本库

什么是版本库呢？版本库又名仓库，英文名repository，你可以简单理解成一个目录，这个目录里面的所有文件都可以被Git管理起来，每个文件的修改、删除，Git都能跟踪，以便任何时刻都可以追踪历史，或者在将来某个时刻可以“还原”。

2.3.1 创建版本库

init之后目录会出现一个.git文件

2.3.2 添加文件到版本库

创建文件 readme.txt

编写readme.txt 文件，内容如下:

Git is a version control system.
Git is free software.
1
2

把一个文件放到Git仓库:
(1) 用命令 git add 告诉Git，把文件添加到仓库:

$ git add readme.txt
1

（2）用命令 git commit 告诉Git，把文件提交到仓库：

$ git commit -m "wrote a readme file"
1

查看提交

$ git log
1

可以多次 add 不同的文件，比如：

$ touch file1.txt,file2.txt,file3.txt
$ git add file1.txt
$ git add file2.txt file3.txt 或者git add . #添加所有untrack文件到stage
1
2
3

使用git status查看git状态

$ git status
On branch master
Changes to be committed:
(use "git restore --staged <file>..." to unstage)
new file: file1.txt
new file: file2.txt
new file: file3.tx
1
2
3
4
5
6
7

提交

$ git commit -m "add 3 files."
1

总结

• git add . 把工作区文件添加到暂存区
• git commit -m “xxxx”：把暂存区(stage)文件提交到分支
• git status：查看git版本库状态
• git log：查看版本提交

2.4 版本控制

2.4.1 修改readme.txt文件，改成如下内容：

Git is a distributed version control system.
Git is free software.
1
2

运行 git status 命令看看结果：

$ git status
On branch 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.txt
no changes added to commit (use "git add" and/or "git commit -a")
1
2
3
4
5
6
7

上面的命令告诉我们，已经修改了文件，但是还没有提交
如果想知道修改了什么东西，需要git diff命令

$ git diff readme.txt
diff --git a/readme.txt b/readme.txt
index 46d49bf..9247db6 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,2 +1,2 @@
-Git is a version control system.
+Git is a distributed version control system.
Git is free software.
1
2
3
4
5
6
7
8
9

之后就可以使用add和commit命令提交到版本库

git add .
git commit -m "add distributed"
1
2

2.4.2 版本回退

1. 准备版本

再次修改readme.txt文件，代码如下：

Git is a distributed version control system.
Git is free software distributed under the GPL
1
2

再次提交

$ git add readme.txt
$ git commit -m "append GPL"
[master 1094adb] append GPL
1 file changed, 1 insertion(+), 1 deletion(-)
1
2
3
4

现在我们可以看见我们一共有四个版本

可以使用如下两个代码查看日志

git log  #可以看见作者时间等等
git log --pretty=oneline # 相对来说精简
1
2

2. 版本回退
   也就是回到之前的版本
   Git必须知道当前版本是哪个版本，在Git中，用 HEAD 表示当前版本，上一个版本就是 HEAD^ ，上上一个版本就是HEAD^^ ，当然往上100个版本写100个 ^ 比较容易数不过来，所以写成 HEAD~100 。
   我们要把当前版本 append GPL 回退到上一个版本 add distributed ，就可以使用 git reset 命令

$ git reset --hard HEAD^^
HEAD is now at e475afc add distributed
1
2

• –hard：重置工作区和暂存区，修改HEAD指针
• –mixed：重置暂存区，修改HEAD指针
• –soft：只修改HEAD指针

查看readme.txt文件

$ cat readme.txt
Git is a distributed version control system.
Git is free software
1
2
3

已经还原到之前的样子

如果想要回到append GPL版本，需要commit id

$ git reset --hard id
HEAD is now at 83b0afe append GPL
1
2

这样就回到了append GPL版本

如果找不到id了，就可以使用git reflog ，它记录了每一次命令

$ git reflog
e475afc HEAD@{1}: reset: moving to HEAD^
1094adb (HEAD -> master) HEAD@{2}: commit: append GPL
e475afc HEAD@{3}: commit: add distributed
eaadf4e HEAD@{4}: commit (initial): wrote a readme file
1
2
3
4
5

2.4.3 工作区和暂存区

1. 工作区（Working Directory）
   就是你在电脑里能看到的目录，比如我的 learngit 文件夹就是一个工作区：
   
2. 版本库（Repository）
   工作区有一个隐藏目录 .git ，这个不算工作区，而是Git的版本库。
   

（1）版本库基本状态
Git的版本库里存了很多东西，其中最重要的就是称为stage（或者叫index）的暂存区，还有Git为我们自动创建的第一个分支 master ，以及指向 master 的一个指针叫 HEAD 。

把文件往Git版本库里添加的时候，是分两步执行的：

• 第一步是用 git add 把文件添加进去，实际上就是把文件修改添加到暂存区；
• 第二步是用 git commit 提交更改，实际上就是把暂存区的所有内容提交到当前分支

先对 readme.txt 做个修改，比如加上一行内容：

Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
1
2
3

然后，在工作区新增一个 LICENSE 文本文件

先用 git status 查看一下状态：

$ git status
On branch 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.txt
Untracked files:
(use "git add <file>..." to include in what will be committed)
LICENSE
no changes added to commit (use "git add" and/or "git commit -a")
1
2
3
4
5
6
7
8
9
10

可以清楚的看见修改文件的和LICENSE 文本文件未被添加过

使用命令：

git add .
1

执行后git版本库状态如下：
git add 命令实际上就是把要提交的所有修改放到暂存区（Stage）

再次查看

$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: LICENSE
modified: readme.txt
1
2
3
4
5
6

执行 git commit 就可以一次性把暂存区的所有修改提交到分支。

$ git commit -m "understand how stage works"
[master e43a48b] understand how stage works
2 files changed, 2 insertions(+)
create mode 100644 LICENSE
1
2
3
4

此时的版本库状态如下：

2.4.4 撤销修改

如果发现文件写错了

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.
My stupid boss still prefers SVN.
1
2
3
4
5
6

查看状态

$ git status
On branch 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.txt
no changes added to commit (use "git add" and/or "git commit -a")
1
2
3
4
5
6
7

发现没有添加和提交，此时可以使用git checkout -- file 可以丢弃工作区的修改：

$ git checkout -- readme.txt
1

命令 git checkout – readme.txt 意思就是，把 readme.txt 文件在工作区的修改全部撤销，这里有
两种情况：

• 一种是 readme.txt 自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；
• 一种是 readme.txt 已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。

总之，就是让这个文件回到最近一次 git commit 或 git add 时的状态。
现在，看看 readme.txt 的文件内容：

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files
1
2
3
4
5

如果已经使用git add 添加到暂存区
查看：

$ git status
On branch master
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
modified: readme.txt
1
2
3
4
5

用命令 git reset HEAD 可以把暂存区的修改撤销掉

$ git reset HEAD readme.txt
Unstaged changes after reset:
M readme.txt
1
2
3

再用 git status 查看一下，现在暂存区是干净的，工作区有修改：

$ git status
On branch 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.txt
1
2
3
4
5
6

再次使用：

$ git checkout -- readme.txt
$ git status
On branch master
nothing to commit, working tree clean
1
2
3
4

总结：

git reset --hard HEAD^ #
#等价于
git reset --mixed HEAD^
git checkout -- readme.txt
1
2
3
4

2.4.5 删除文件

添加一个新文件 test.txt 到Git并且提交：

$ git add test.txt
$ git commit -m "add test.txt"
[master b84166e] add test.txt
1 file changed, 1 insertion(+)
create mode 100644 test.txt
1
2
3
4
5

rm 命令删除：

$ rm test.txt
1

删除了文件，因此，工作区和版本库就不一致了， git status 命令会立刻告诉你哪些文件被删除了：

$ git status
On branch master
Changes not staged for commit:
(use "git add/rm <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
deleted: test.txt
no changes added to commit (use "git add" and/or "git commit -a")
1
2
3
4
5
6
7

确实要从版本库中删除该文件，那就用命令 git rm 删掉，并且 git commit

$ git rm test.txt
rm 'test.txt'
$ git commit -m "remove test.txt"
[master d46f35e] remove test.txt
1 file changed, 1 deletion(-)
delete mode 100644 test.txt
1
2
3
4
5
6

要是删错了，因为版本库里还有呢，所以可以很轻松地把误删的文件恢复到最新版本：

$ git checkout -- test.txt
1

3. 远程仓库

3.1 使用远程仓库

完全可以自己搭建一台运行Git的服务器，不过也可以使用现有的Git远程库，应用比较广泛的如下：

• github
• gitee

1. 使用SSH协议：
   ssh基于非对称加密的免密登录原理
   

对称加密：密码本是一个

• MD5

非对称加密，秘钥是一对(公钥/私钥)

• rsa

3.2 添加远程仓库

第1步：创建SSH Key。在用户主目录下，看看有没有.ssh目录，如果有，再看看这个目录下有没有id_rsa 和 id_rsa.pub 这两个文件，如果已经有了，可直接跳到下一步。如果没有，打开Shell（Windows下打开Git Bash），创建SSH Key：

$ ssh-keygen -t rsa -C "lxsong77@163.com"
#用户宿主目录下.ssh c:\Users\Administrator\.ssh\
1
2

根据图片所示操作

2. HTTS协议
   当然不配置公钥也可以使用HTTS协议，在使用HTTPS协议时输入用户名/密码
3. 克隆
   使用https协议

git clone https://gitee.com/halo-dev/halo.git
#第一次访问需要输入gitee的用户名密码
1
2

使用ssh协议

git clone git@gitee.com:halo-dev/halo.git
1

3.3 分支管理

分支就是git世界的平行宇宙，当你正在电脑前努力学习Git的时候，另一个你正在另一个平行宇宙里努力学习SVN。

3.3.1 创建和合并分支

一开始的时候， master 分支是一条线，Git用 master 指向最新的提交，再用 HEAD 指向 master ，就能确定当前分支，以及当前分支的提交点：

每次提交， master 分支都会向前移动一步，这样，随着你不断提交， master 分支的线也越来越长。

当我们创建新的分支，例如 dev 时，Git新建了一个指针叫 dev ，指向 master 相同的提交，再把HEAD 指向 dev ，就表示当前分支在 dev 上：

从现在开始，对工作区的修改和提交就是针对 dev 分支了，比如新提交一次后， dev 指针往前移动一步，而 master 指针不变：

假如我们在 dev 上的工作完成了，就可以把 dev 合并到 master 上。Git怎么合并呢？最简单的方法，就是直接把 master 指向 dev 的当前提交，就完成了合并：

合并完分支后，甚至可以删除 dev 分支。删除 dev 分支就是把 dev 指针给删掉，删掉后，我们就剩下了一条 master 分支：

实战：
创建 dev 分支，然后切换到 dev 分支：

#创建
$ git checkout -b dev
Switched to a new branch 'dev'

#查看日志
git log --oneline
git log --pretty=oneline --abbrev-commit #和上面的命令等价
1
2
3
4
5
6
7

• -pretty=oneline：显示单行
• -abbrev-commit：缩写commit id

其中上的：git checkout -b dev相当于下面两句

$ git branch dev
$ git checkout dev
Switched to branch 'dev'
1
2
3

用 git branch 命令查看当前分支：

$ git branch
* dev
master
1
2
3

git branch 命令会列出所有分支，当前分支前面会标一个 * 号。

我们就可以在 dev 分支上正常提交，比如对 readme.txt 做个修改，加上一行：Creating a new branch is quick.
然后提交：

$ git add readme.txt
$ git commit -m "branch test"
[dev b17d20e] branch test
1 file changed, 1 insertion(+)
1
2
3
4

现在， dev 分支的工作完成，我们就可以切换回 master 分支：

$ git checkout master
Switched to branch 'master'
1
2

切换回 master 分支后，再查看一个 readme.txt 文件，刚才添加的内容不见了！因为那个提交是在 dev 分支上，而 master 分支此刻的提交点并没有变：

我们把 dev 分支的工作成果合并到 master 分支上：

$ git merge dev
Updating d46f35e..b17d20e
Fast-forward
readme.txt | 1 +
1 file changed, 1 insertion(+)
1
2
3
4
5

合并后，再查看 readme.txt 的内容，就可以看到，和 dev 分支的最新提交是完全一样的。

合并完成后，就可以放心地删除 dev 分支了：

$ git branch -d dev
Deleted branch dev (was b17d20e).
1
2

总结：

• git checkout
  git checkout – file：把版本课的文件重置到工作区（撤销工作区的修改）
  git checkout master：切换到master分支
  git checkout -b dev：创建dev分支，并且切换到dev分支
• git branch
  git branch：列表分支分支，有*当前的分支
  git branch dev：创建dev分支，如果切换需要git checkout dev
  git branch -d dev：删除分支
• git merge：合并分支

#master合并dev分支
git checkout master
git merge dev #使master分支合并dev分支
1
2
3

3.3.2 版本冲突

准备新的 feature1 分支，继续我们的新分支开发：

$ git checkout -b feature1
Switched to a new branch 'feature1'
git branch feature1 #创建分支
git checkout feature1 #切换分支
git branch #查看分支
1
2
3
4
5

修改 readme.txt 最后一行，改为：

Creating a new branch is quick AND simple.
1

在 feature1 分支上提交：

$ git add readme.txt
$ git commit -m "AND simple"
[feature1 14096d0] AND simple
1 file changed, 1 insertion(+), 1 deletion(-)
1
2
3
4

在切换到master分支上面：

$ git checkout master
Switched to branch 'master'
Your branch is ahead of 'origin/master' by 1 commit.
(use "git push" to publish your local commits)
1
2
3
4

在 master 分支上把 readme.txt 文件的最后一行改为：

Creating a new branch is quick & simple.
1

提交

$ git add readme.txt
$ git commit -m "& simple"
[master 5dc6824] & simple
1 file changed, 1 insertion(+), 1 deletion(-)
1
2
3
4

现在， master 分支和 feature1 分支各自都分别有新的提交，变成了这样：

此时是无法合并的：

$ git merge feature1
Auto-merging readme.txt
CONFLICT (content): Merge conflict in readme.txt
Automatic merge failed; fix conflicts and then commit the result.
1
2
3
4

这个是说readme.txt使有冲突的， git status 也可以告诉我们冲突的文件：

$ git status
On branch master
Your branch is ahead of 'origin/master' by 2 commits.
(use "git push" to publish your local commits)
You have unmerged paths.
(fix conflicts and run "git commit")
(use "git merge --abort" to abort the merge)
Unmerged paths:
(use "git add <file>..." to mark resolution)
both modified: readme.txt
no changes added to commit (use "git add" and/or "git commit -a")
1
2
3
4
5
6
7
8
9
10
11

我们可以直接查看readme.txt的内容：

Git is a distributed version control system.
Git is free software distributed under the GPL.
Git has a mutable index called stage.
Git tracks changes of files.
<<<<<<< HEAD
Creating a new branch is quick & simple.
=======
Creating a new branch is quick AND simple.
>>>>>>> feature1
1
2
3
4
5
6
7
8
9

Git用 <<<<<<< ， ======= ， >>>>>>> 标记出不同分支的内容，我们修改如下后保存：

Creating a new branch is quick and simple.
1

再次提交：

$ git add readme.txt
$ git commit -m "conflict fixed"
[master cf810e4] conflict fixed
1
2
3

现在， master 分支和 feature1 分支变成了下图所示：

用带参数的 git log 也可以看到分支的合并情况：

$ git log --graph --pretty=oneline --abbrev-commit
* cf810e4 (HEAD -> master) conflict fixed
|\
| * 14096d0 (feature1) AND simple
* | 5dc6824 & simple
|/
* b17d20e branch test
* d46f35e (origin/master) remove test.txt
* b84166e add test.txt
* 519219b git tracks changes
* e43a48b understand how stage works
* 1094adb append GPL
* e475afc add distributed
* eaadf4e wrote a readme file
1
2
3
4
5
6
7
8
9
10
11
12
13
14

最后删除分支：

$ git branch -d feature1
Deleted branch feature1 (was 14096d0).
1
2

3.3.3 分支策略

团队合作的分支看起来就像这样：

直接实战：

先创建bob开发人员：

#创建本地dev分支
git checkout -b dev
#提交dev给服务器
git push origin dev
#创建bob的本地分支
git checkout -b bob
#创建env.txt
touch env.txt
#提交
git add .
git commit -m "add env bob"
#回到dev，合并bob分支
git checkout dev
git merge bob
#上传dev到远程
git push origin dev
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

再创建Mickey开发人员

cd f:\mickey
git clone git@gitee.com:lxsong77/learngit.git
#注意，只下载master分支，其他分支不会被clone
git checkout -b dev
git branch --set-upstream-to=origin/dev dev
#等价于
git checkout -b dev origin/dev
#拉取dev分支
git pull origin dev
#创建mickey分支
git checkout -b mickey
#修改env.txt增加内容"mickey env"
vim env.txt
#提交
git add .
git commit -m "update env by mickey"
#合并到dev
git checkout dev
git merge mickey
#上传
git push origin dev
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

合并master分支

#拉取最新代码
git pull origin master
git pull origin dev
git checkout master
git merge dev
#上传
git push origin master
1
2
3
4
5
6
7

3.3.4 分支实战

1. Bug分支

​ 软件开发中，bug就像家常便饭一样。有了bug就需要修复，在Git中，由于分支是如此的强大，所以，每个bug都可以通过一个新的临时分支来修复，修复后，合并分支，然后将临时分支删除。

​ 当你接到一个修复一个代号101的bug的任务时，很自然地，你想创建一个分支issue-101来修复它，但是，等等，当前正在dev上进行的工作还没有提交：

$ git status
On branch dev
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	new file:   hello.py

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.txt
1
2
3
4
5
6
7
8
9
10
11
12

​ 并不是你不想提交，而是工作只进行到一半，还没法提交，预计完成还需1天时间。但是，必须在两个小时内修复该bug，怎么办？

​ 幸好，Git还提供了一个stash功能，可以把当前工作现场“储藏”起来，等以后恢复现场后继续工作：

$ git stash
Saved working directory and index state WIP on dev: f52c633 add merge
1
2

​ 现在，用git status查看工作区，就是干净的（除非有没有被Git管理的文件），因此可以放心地创建分支来修复bug。

​ 首先确定要在哪个分支上修复bug，假定需要在master分支上修复，就从master创建临时分支：

$ git checkout master
Switched to branch 'master'
Your branch is ahead of 'origin/master' by 6 commits.
  (use "git push" to publish your local commits)

$ git checkout -b issue-101
Switched to a new branch 'issue-101'
1
2
3
4
5
6
7

​ 现在修复bug，需要把“Git is free software …”改为“Git is a free software …”，然后提交：

$ git add readme.txt 
$ git commit -m "fix bug 101"
[issue-101 4c805e2] fix bug 101
 1 file changed, 1 insertion(+), 1 deletion(-)
1
2
3
4

​ 修复完成后，切换到master分支，并完成合并，最后删除issue-101分支：

$ git checkout master
Switched to branch 'master'
Your branch is ahead of 'origin/master' by 6 commits.
  (use "git push" to publish your local commits)

$ git merge --no-ff -m "merged bug fix 101" issue-101
Merge made by the 'recursive' strategy.
 readme.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
1
2
3
4
5
6
7
8
9

​ 太棒了，原计划两个小时的bug修复只花了5分钟！现在，是时候接着回到dev分支干活了！

$ git checkout dev
Switched to branch 'dev'

$ git status
On branch dev
nothing to commit, working tree clean
1
2
3
4
5
6

​ 工作区是干净的，刚才的工作现场存到哪去了？用git stash list命令看看：

$ git stash list
stash@{0}: WIP on dev: f52c633 add merge
1
2

​ 工作现场还在，Git把stash内容存在某个地方了，但是需要恢复一下，有两个办法：

​ 一是用git stash apply恢复，但是恢复后，stash内容并不删除，你需要用git stash drop来删除；

​ 另一种方式是用git stash pop，恢复的同时把stash内容也删了：

$ git stash pop
On branch dev
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	new file:   hello.py

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

Dropped refs/stash@{0} (5d677e2ee266f39ea296182fb2354265b91b3b2a)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

​ 再用git stash list查看，就看不到任何stash内容了：

$ git stash list
1

​ 你可以多次stash，恢复的时候，先用git stash list查看，然后恢复指定的stash，用命令：

$ git stash apply stash@{0}
1

​ 在master分支上修复了bug后，我们要想一想，dev分支是早期从master分支分出来的，所以，这个bug其实在当前dev分支上也存在。

​ 同样的bug，要在dev上修复，我们只需要把4c805e2 fix bug 101这个提交所做的修改“复制”到dev分支。注意：我们只想复制4c805e2 fix bug 101这个提交所做的修改，并不是把整个master分支merge过来。

​ 为了方便操作，Git专门提供了一个cherry-pick命令，让我们能复制一个特定的提交到当前分支：

$ git branch
* dev
  master
$ git cherry-pick 4c805e2
[master 1d4b803] fix bug 101
 1 file changed, 1 insertion(+), 1 deletion(-)
1
2
3
4
5
6

​ Git自动给dev分支做了一次提交，注意这次提交的commit是1d4b803，它并不同于master的4c805e2，因为这两个commit只是改动相同，但确实是两个不同的commit。用git cherry-pick，我们就不需要在dev分支上手动再把修bug的过程重复一遍。

​ 有些聪明的童鞋会想了，既然可以在master分支上修复bug后，在dev分支上可以“重放”这个修复过程，那么直接在dev分支上修复bug，然后在master分支上“重放”行不行？当然可以，不过你仍然需要git stash命令保存现场，才能从dev分支切换到master分支。

完整的过程命令

#dev分支工作
git checkout dev
echo 'working on stage..' >> readme.txt
git add .
echo 'working on work space' >> readme.txt

#以上是现有工作
#接到一个改正bug101的任务
#现有工作，存储起来
git stash
#列表stash
git stash list

#切换回到master分支修改bug101
git checkout master
#创建修改bug101的分支
git checkout -b issue-101
echo 'fixed issue-101 bug' >> readme.txt
git add .
git commit -m "fixed bug 101"
#合并101分支
git checkout master
git merge issue-101

#bug改完了，回来继续工作
git checkout dev
git stash pop #把之前存储的工作，弹出
。。。。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2. Feature分支

​ 软件开发中，总有无穷无尽的新的功能要不断添加进来。

​ 添加一个新功能时，你肯定不希望因为一些实验性质的代码，把主分支搞乱了，所以，每添加一个新功能，最好新建一个feature分支，在上面开发，完成后，合并，最后，删除该feature分支。

​ 现在，你终于接到了一个新任务：开发代号为Vulcan的新功能，该功能计划用于下一代星际飞船。

​ 于是准备开发：

$ git checkout -b feature-vulcan
Switched to a new branch 'feature-vulcan'
1
2

​ 5分钟后，开发完毕：

$ git add vulcan.py

$ git status
On branch feature-vulcan
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	new file:   vulcan.py

$ git commit -m "add feature vulcan"
[feature-vulcan 287773e] add feature vulcan
 1 file changed, 2 insertions(+)
 create mode 100644 vulcan.py
1
2
3
4
5
6
7
8
9
10
11
12
13

​ 切回dev，准备合并：

$ git checkout dev
1

​ 一切顺利的话，feature分支和bug分支是类似的，合并，然后删除。

​ 但是！

​ 就在此时，接到上级命令，因经费不足，新功能必须取消！

​ 虽然白干了，但是这个包含机密资料的分支还是必须就地销毁：

$ git branch -d feature-vulcan
error: The branch 'feature-vulcan' is not fully merged.
If you are sure you want to delete it, run 'git branch -D feature-vulcan'.
1
2
3

​ 销毁失败。Git友情提醒，feature-vulcan分支还没有被合并，如果删除，将丢失掉修改，如果要强行删除，需要使用大写的-D参数。。

​ 现在我们强行删除：

$ git branch -D feature-vulcan
Deleted branch feature-vulcan (was 287773e).
1
2

​ 终于删除成功！

​ 总结：开发一个新feature，最好新建一个分支；如果要丢弃一个没有被合并过的分支，可以通过git branch -D <name>强行删除。

3. 多人协作

​ 当你从远程仓库克隆时，实际上Git自动把本地的master分支和远程的master分支对应起来了，并且，远程仓库的默认名称是origin。

​ 要查看远程库的信息，用git remote：

$ git remote
origin
1
2

​ 或者，用git remote -v显示更详细的信息：

$ git remote -v
origin  git@github.com:michaelliao/learngit.git (fetch)
origin  git@github.com:michaelliao/learngit.git (push)
1
2
3

​ 上面显示了可以抓取和推送的origin的地址。如果没有推送权限，就看不到push的地址。

（1）推送分支

​ 推送分支，就是把该分支上的所有本地提交推送到远程库。推送时，要指定本地分支，这样，Git就会把该分支推送到远程库对应的远程分支上：

$ git push origin master
1

如果要推送其他分支，比如dev，就改成：

$ git push origin dev
1

但是，并不是一定要把本地分支往远程推送，那么，哪些分支需要推送，哪些不需要呢？

• master分支是主分支，因此要时刻与远程同步；
• dev分支是开发分支，团队所有成员都需要在上面工作，所以也需要与远程同步；
• bug分支只用于在本地修复bug，就没必要推到远程了，除非老板要看看你每周到底修复了几个bug；
• feature分支是否推到远程，取决于你是否和你的小伙伴合作在上面开发。

总之，就是在Git中，分支完全可以在本地自己藏着玩，是否推送，视你的心情而定！

（2）抓取分支

​ 多人协作时，大家都会往master和dev分支上推送各自的修改。

​ 现在，模拟一个你的小伙伴，可以在另一台电脑（注意要把SSH Key添加到GitHub）或者同一台电脑的另一个目录下克隆：

$ git clone git@github.com:michaelliao/learngit.git
Cloning into 'learngit'...
remote: Counting objects: 40, done.
remote: Compressing objects: 100% (21/21), done.
remote: Total 40 (delta 14), reused 40 (delta 14), pack-reused 0
Receiving objects: 100% (40/40), done.
Resolving deltas: 100% (14/14), done.
1
2
3
4
5
6
7

​ 当你的小伙伴从远程库clone时，默认情况下，你的小伙伴只能看到本地的master分支。不信可以用git branch命令看看：

$ git branch
* master
1
2

​ 现在，你的小伙伴要在dev分支上开发，就必须创建远程origin的dev分支到本地，于是他用这个命令创建本地dev分支：

git checkout -b dev
git push origin dev
$ git checkout -b dev origin/dev #创建dev分支，同时连接远程的dev分支
1
2
3

​ 现在，他就可以在dev上继续修改，然后，时不时地把dev分支push到远程：

#创建一个本地的bob分支
git checkout -b bob
touch en.txt

$ git add env.txt

$ git commit -m "add env"
[dev 7a5e5dd] add env
 1 file changed, 1 insertion(+)
 create mode 100644 env.txt

#切换dev分支
git checkout dev
git merge bob

$ git push origin dev
Counting objects: 3, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (2/2), done.
Writing objects: 100% (3/3), 308 bytes | 308.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
   f52c633..7a5e5dd  dev -> dev
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

​ 你的小伙伴已经向origin/dev分支推送了他的提交，而碰巧你也对同样的文件作了修改，并试图推送：

cd f:\mickey
git checkout -b dev origin/dev
#等价下面两个命令
git checkout -b dev
git branch --set-upstream-to=origin/dev dev
1
2
3
4
5

git checkout -b mickey

$ cat env.txt
env

$ git add env.txt

$ git commit -m "add new env"
[dev 7bd91f1] add new env
 1 file changed, 1 insertion(+)
 create mode 100644 env.txt

$ git push origin dev
To github.com:michaelliao/learngit.git
 ! [rejected]        dev -> dev (non-fast-forward)
error: failed to push some refs to 'git@github.com:michaelliao/learngit.git'
hint: Updates were rejected because the tip of your current branch is behind
hint: its remote counterpart. Integrate the remote changes (e.g.
hint: 'git pull ...') before pushing again.
hint: See the 'Note about fast-forwards' in 'git push --help' for details.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

​ 推送失败，因为你的小伙伴的最新提交和你试图推送的提交有冲突，解决办法也很简单，Git已经提示我们，先用git pull把最新的提交从origin/dev抓下来，然后，在本地合并，解决冲突，再推送：

$ git pull
There is no tracking information for the current branch.
Please specify which branch you want to merge with.
See git-pull(1) for details.

    git pull <remote> <branch>

If you wish to set tracking information for this branch you can do so with:

    git branch --set-upstream-to=origin/<branch> dev
1
2
3
4
5
6
7
8
9
10

​ git pull也失败了，原因是没有指定本地dev分支与远程origin/dev分支的链接，根据提示，设置dev和origin/dev的链接：

$ git branch --set-upstream-to=origin/dev dev
Branch 'dev' set up to track remote branch 'dev' from 'origin'.
1
2

​ 再pull：

$ git pull
Auto-merging env.txt
CONFLICT (add/add): Merge conflict in env.txt
Automatic merge failed; fix conflicts and then commit the result.
1
2
3
4

​ 这回git pull成功，但是合并有冲突，需要手动解决，解决的方法和分支管理中的解决冲突完全一样。解决后，提交，再push：

$ git commit -m "fix env conflict"
[dev 57c53ab] fix env conflict

$ git push origin dev
Counting objects: 6, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (6/6), 621 bytes | 621.00 KiB/s, done.
Total 6 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
   7a5e5dd..57c53ab  dev -> dev
1
2
3
4
5
6
7
8
9
10
11

因此，多人协作的工作模式通常是这样：

1. 首先，可以试图用git push origin <branch-name>推送自己的修改；
2. 如果推送失败，则因为远程分支比你的本地更新，需要先用git pull试图合并；
3. 如果合并有冲突，则解决冲突，并在本地提交；
4. 没有冲突或者解决掉冲突后，再用git push origin <branch-name>推送就能成功！

如果git pull提示no tracking information，则说明本地分支和远程分支的链接关系没有创建，用命令git branch --set-upstream-to <branch-name> origin/<branch-name>。

这就是多人协作的工作模式，一旦熟悉了，就非常简单。

总结：

• 查看远程库信息，使用git remote -v；
• 本地新建的分支如果不推送到远程，对其他人就是不可见的；
• 从本地推送分支，使用git push origin branch-name，如果推送失败，先用git pull抓取远程的新提交；
• 在本地创建和远程分支对应的分支，使用git checkout -b branch-name origin/branch-name，本地和远程分支的名称最好一致；
• 建立本地分支和远程分支的关联，使用git branch --set-upstream branch-name origin/branch-name；
• 从远程抓取分支，使用git pull，如果有冲突，要先处理冲突。

3.3.5 标签管理

1. 创建标签

​ 在Git中打标签非常简单，首先，切换到需要打标签的分支上：

$ git branch
* dev
  master
$ git checkout master
Switched to branch 'master'
1
2
3
4
5

​ 然后，敲命令git tag <name>就可以打一个新标签：

$ git tag v1.0
1

​ 可以用命令git tag查看所有标签：

$ git tag
v1.0
1
2

​ 默认标签是打在最新提交的commit上的。有时候，如果忘了打标签，比如，现在已经是周五了，但应该在周一打的标签没有打，怎么办？

​ 方法是找到历史提交的commit id，然后打上就可以了：

$ git log --pretty=oneline --abbrev-commit
12a631b (HEAD -> master, tag: v1.0, origin/master) merged bug fix 101
4c805e2 fix bug 101
e1e9c68 merge with no-ff
f52c633 add merge
cf810e4 conflict fixed
5dc6824 & simple
14096d0 AND simple
b17d20e branch test
d46f35e remove test.txt
b84166e add test.txt
519219b git tracks changes
e43a48b understand how stage works
1094adb append GPL
e475afc add distributed
eaadf4e wrote a readme file
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

​ 比方说要对add merge这次提交打标签，它对应的commit id是f52c633，敲入命令：

$ git tag v0.9 f52c633
1

​ 再用命令git tag查看标签：

$ git tag
v0.9
v1.0
1
2
3

​ 注意，标签不是按时间顺序列出，而是按字母排序的。可以用git show <tagname>查看标签信息：

$ git show v0.9
commit f52c63349bc3c1593499807e5c8e972b82c8f286 (tag: v0.9)
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 21:56:54 2018 +0800

    add merge

diff --git a/readme.txt b/readme.txt
...
1
2
3
4
5
6
7
8
9

​ 可以看到，v0.9确实打在add merge这次提交上。

​ 还可以创建带有说明的标签，用-a指定标签名，-m指定说明文字：

$ git tag -a v0.1 -m "version 0.1 released" b0fbe25
1

​ 用命令git show <tagname>可以看到说明文字：

$ git show v0.1
tag v0.1
Tagger: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 22:48:43 2018 +0800

version 0.1 released

commit 1094adb7b9b3807259d8cb349e7df1d4d6477073 (tag: v0.1)
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 21:06:15 2018 +0800

    append GPL

diff --git a/readme.txt b/readme.txt
...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

​ 注意：标签总是和某个commit挂钩。如果这个commit既出现在master分支，又出现在dev分支，那么在这两个分支上都可以看到这个标签。

总结：

• 命令git tag <tagname>用于新建一个标签，默认为HEAD，也可以指定一个commit id；
• 命令git tag -a <tagname> -m "blablabla..."可以指定标签信息；
• 命令git tag可以查看所有标签。

2. 操作标签

​ 如果标签打错了，也可以删除：

$ git tag -d v0.1
Deleted tag 'v0.1' (was f15b0dd)
1
2

​ 因为创建的标签都只存储在本地，不会自动推送到远程。所以，打错的标签可以在本地安全删除。

​ 如果要推送某个标签到远程，使用命令git push origin <tagname>：

$ git push origin v1.0
Total 0 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
 * [new tag]         v1.0 -> v1.0
1
2
3
4

​ 或者，一次性推送全部尚未推送到远程的本地标签：

$ git push origin --tags
Total 0 (delta 0), reused 0 (delta 0)
To github.com:michaelliao/learngit.git
 * [new tag]         v0.9 -> v0.9
1
2
3
4

​ 如果标签已经推送到远程，要删除远程标签就麻烦一点，先从本地删除：

$ git tag -d v0.9
Deleted tag 'v0.9' (was f52c633)
1
2

​ 然后，从远程删除。删除命令也是push，但是格式如下：

$ git push origin :refs/tags/v0.9
To github.com:michaelliao/learngit.git
 - [deleted]         v0.9
1
2
3

​ 要看看是否真的从远程库删除了标签，可以登陆GitHub查看。

小结

• 命令git push origin <tagname>可以推送一个本地标签；
• 命令git push origin --tags可以推送全部未推送过的本地标签；
• 命令git tag -d <tagname>可以删除一个本地标签；
• 命令git push origin :refs/tags/<tagname>可以删除一个远程标签。