转载：http://www.cnblogs.com/woshimrf/p/git-workflow.html

目录

1.1.创造仓库
1.2.
模拟用户A
1.3.
模仿用户B
1.4.
效仿用户A
1.5.
仿照用户C
1.6.
模仿用户B
1.7.
模拟用户C
2.1
模拟用户C
2.2
模拟用户D
2.3
C继续支付
 2.4
D继续支付
 2.5 C
提交
 2.6 C
提PR
2.7
C修改再push
2.8
C发现提交次数过多，历史太乱，合并一些历史
 2.9
C再次push
2.10 新的merge方式：
rebase
2.11 那时候D也已毕了
2.12 提交前rebase
最后结果

目录

1.1.成立仓库
1.2.
模仿用户A
1.3.
模拟用户B
1.4.
仿照用户A
1.5.
效仿用户C
1.6.
模拟用户B
1.7.
仿照用户C
2.1
模拟用户C
2.2
模拟用户D
2.3
C继续支付
 2.4
D继续支付
 2.5 C
提交
 2.6 C
提PR
2.7
C修改再push
2.8
C发现提交次数过多，历史太乱，合并一些历史
 2.9
C再次push
2.10 新的merge方式：
rebase
2.11 那时候D也不负众望了
2.12 提交前rebase
最终结出

前言

直接在动用git做版本控制，也直接工作很顺畅，直到和人家暴发争辨的时候。那才注意到git
工作流并不是那么不难。比如，以前遇到的清理历史。百度到的材料很多，重复性也很多，但实践性操作很少，我很难直接精通其所表明的意义。直接以偏概全平日获得错误的定论，只好用时间去验证真理了，不然看到的结果都是似懂非懂，最终依旧一团糟。

前言

一贯在使用git做版本控制，也平素工作很顺畅，直到和外人暴发顶牛的时候。那才注意到git
工作流并不是那么粗略。比如，之前蒙受的理清历史。百度到的材料很多，重复性也很多，但实践性操作很少，我很难直接领会其所发挥的意义。直接一概而论常常得到错误的定论，只可以用时间去印证真理了，不然看到的结果都是似懂非懂，最终照旧一团糟。

学习git工作流

1. 最简便的利用，不推荐

1. 最简易的施用，不推荐

1.1.创设仓库

$ pwd
/home/ryan/workspace/l4git-workflow
$ touch readme.md
$ ls
readme.md
$ touch .gitignore
$ git init
初始化空的 Git 仓库于 /home/ryan/workspace/l4git-workflow/.git/
$ touch test.txt
$ git add .
$ git commit -m "init"
[master （根提交） dae77d6] init
 3 files changed, 12 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 readme.md
 create mode 100644 test.txt
$ git remote add origin git@github.com:Ryan-Miao/l4git-workflow.git
$ git push -u origin master
对象计数中: 5, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (3/3), 完成.
写入对象中: 100% (5/5), 388 bytes | 0 bytes/s, 完成.
Total 5 (delta 0), reused 0 (delta 0)
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> master
分支 master 设置为跟踪来自 origin 的远程分支 master。

1.1.创办仓库

$ pwd
/home/ryan/workspace/l4git-workflow
$ touch readme.md
$ ls
readme.md
$ touch .gitignore
$ git init
初始化空的 Git 仓库于 /home/ryan/workspace/l4git-workflow/.git/
$ touch test.txt
$ git add .
$ git commit -m "init"
[master （根提交） dae77d6] init
 3 files changed, 12 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 readme.md
 create mode 100644 test.txt
$ git remote add origin git@github.com:Ryan-Miao/l4git-workflow.git
$ git push -u origin master
对象计数中: 5, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (3/3), 完成.
写入对象中: 100% (5/5), 388 bytes | 0 bytes/s, 完成.
Total 5 (delta 0), reused 0 (delta 0)
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> master
分支 master 设置为跟踪来自 origin 的远程分支 master。

1.2. 模仿用户A

git clone git@github.com:Ryan-Miao/l4git-workflow.git
git checkout a
touch a.txt
//write one
//....
$ git add .
$ git commit -m "one"
[a 53ff45e] one
 2 files changed, 34 insertions(+), 2 deletions(-)
 create mode 100644 a.txt

这时，a还不曾付诸到origin。 git log 如下：

1.2. 模仿用户A

git clone git@github.com:Ryan-Miao/l4git-workflow.git
git checkout a
touch a.txt
//write one
//....
$ git add .
$ git commit -m "one"
[a 53ff45e] one
 2 files changed, 34 insertions(+), 2 deletions(-)
 create mode 100644 a.txt

此刻，a还尚无付诸到origin。 git log 如下：

1.3. 仿照用户B

git clone git@github.com:Ryan-Miao/l4git-workflow.git
git checkout b

$ touch b.txt

//write something
//…

$ git add .
$ git commit -m "b write one"
[b 847078e] b write one
 1 file changed, 1 insertion(+)
 create mode 100644 b.txt

//write something
//….
$ git add . $ git commit -m "b write two" [b 3f30f41] b write two 1 file changed, 2 insertions(+), 1 deletion(-)

此时，git log如下

1.3. 效仿用户B

git clone git@github.com:Ryan-Miao/l4git-workflow.git
git checkout b

$ touch b.txt

//write something
//…

$ git add .
$ git commit -m "b write one"
[b 847078e] b write one
 1 file changed, 1 insertion(+)
 create mode 100644 b.txt

//write something
//….
$ git add . $ git commit -m "b write two" [b 3f30f41] b write two 1 file changed, 2 insertions(+), 1 deletion(-)

此时，git log如下

1.4. 模拟用户A

A和B分别是在地面开发，所以那种顺序是大惑不解的，也许A比B先commit一回，也许B先commit三遍。那里的程序是指commit的大运戳。但都是在本土提交的代码。
write something

git add .
git commit -m "a write two"

wirte something

git add .
git commit -m "write three"

A push to server branch a

$ git push origin a:a
Total 0 (delta 0), reused 0 (delta 0)
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      a -> a

A created a Pull Request

1.4. 仿照用户A

A和B分别是在本地开发，所以那种顺序是不解的，也许A比B先commit一回，也许B先commit几遍。那里的主次是指commit的时光戳。但都是在该地提交的代码。
write something

git add .
git commit -m "a write two"

wirte something

git add .
git commit -m "write three"

A push to server branch a

$ git push origin a:a
Total 0 (delta 0), reused 0 (delta 0)
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      a -> a

A created a Pull Request

1.5. 模仿用户C

C review the PR and then merged it.

那儿，github的历史如下：

可以看出，merge的时候多了五回commit，message默许为 Merge pull request #1 from Ryan-Miao/a...
明天看起来，唯有a一个人的历史记录，还算清楚，a做了3次提交。

1.5. 模拟用户C

C review the PR and then merged it.

那时候，github的历史如下：

可以看看，merge的时候多了四次commit，message默认为 Merge pull request #1 from Ryan-Miao/a...
现行看起来，唯有a一个人的历史记录，还算清楚，a做了3次提交。

1.6. 仿照用户B

用户B提交前先pull master，更新最新的代码到地面，避免争辨。

 git fetch
 git merge origin/master

此时log看起来有些乱。如下：

令人备感混乱的是b原来的历史唯有和谐的交付，更新了master到地方之后，历史记录被插入了master中的历史。于是，发现原本自己到底的历史被中间插入多次commit。甚至四次merge
master的日志显得又长又碍眼。但不管怎么说，B依旧要交给的。

于是乎，B提交到长途分支b：

1.6. 仿照用户B

用户B提交前先pull master，更新最新的代码到地面，幸免争辩。

 git fetch
 git merge origin/master

这儿log看起来有点乱。如下：

令人倍感混乱的是b原来的历史唯有和谐的交付，更新了master到地点之后，历史记录被插入了master中的历史。于是，发现原来自己到底的野史被中间插入多次commit。甚至两遍merge
master的日志显得又长又碍眼。但不管怎么说，B依旧要提交的。

于是，B提交到长途分支b：

1.7. 模仿用户C

那儿，A完结了feature a，然后提了PR，然后找别人C
merge了。而后，B也水到渠成了feature b，提了PR，要求review and merge。 C
review之后，approved，然后D review， D merge。

那儿，项目为主走上规范。feature一个一个丰盛进去，重复在此之前的工作流程：
fetch -》 work -》 commit -》 push -》 PR -》 merged。
下一场，项目历史就改成了如此：

一眼大约看起来还好，每趟都能看到提交历史，只要不是message写的专门少，大概可以领略如今付出的情节。不过，仔细一看，顺序好像不对。近年来一起四个feature，但历史却远远超越2个。没关系，保险细粒度更易于反映开发进程。可是，那几个历史并不是鲁人持竿feature的颁发顺序，那么，当自己想要找到feature
a的时候就很难串联起来。倘诺commit丰富多，时间跨度丰硕大，甚至根本看不出来feature
a到底做了怎么着修改。

那时想要使用图形化git 历史工具来接济精晓历史：

此处，还好，还勉强能看到走向。但当10个广大个人同时支付来说，线几乎不可能看了，时间跨度足够大的话，线也看不完。

故此，那种方式，正是我们温馨眼前利用的形式。差评。那还不算完，前边更大的不方便来了。最头阵布的feature
a出了难题，必须回滚。如何是好到。关于回滚，就是另一个话题了。
但我们理应领悟使用revert而不是reset.
但revert只可以回滚指定的commit，或者延续的commit，而且revert无法revert
merge操作。那样，想回滚feature a,
大家即将找到a的五遍提交的本子号，然后由于不是接连的，分别revert。那会导致复杂到不想处理了。好在github给了便民的东西，PR提供了revert的空子。找到往日的PR。

不过，这纯属不是个好操作！

1.7. 仿照用户C

这会儿，A已毕了feature a，然后提了PR，然后找旁人C
merge了。而后，B也到位了feature b，提了PR，须要review and merge。 C
review之后，approved，然后D review， D merge。

那时，项目基本走上正式。feature一个一个抬高进去，重复此前的行事流程：
fetch -》 work -》 commit -》 push -》 PR -》 merged。
接下来，项目历史就变成了这么：

一眼差不多看起来还好，每回都能观看提交历史，只要不是message写的专门少，大约可以精晓近期交付的始末。不过，仔细一看，顺序好像不对。近日统计五个feature，但历史却远远超过2个。没关系，保险细粒度更便于反映开发进程。不过，这个历史并不是按照feature的发布顺序，那么，当我想要找到feature
a的时候就很难串联起来。如若commit丰富多，时间跨度丰富大，甚至根本看不出来feature
a到底做了怎么修改。

那时候想要使用图形化git 历史工具来赞助精晓历史：

那边，还好，还勉强能观察走向。但当10个广大个人同时开发以来，线大概不可能看了，时间跨度足够大的话，线也看不完。

故而，那种情势，正是大家团结眼前接纳的情势。差评。那还不算完，前边更大的狼狈来了。最头阵布的feature
a出了难题，必须回滚。怎么形成。关于回滚，就是另一个话题了。
但大家应该驾驭使用revert而不是reset.
但revert只可以回滚指定的commit，或者连续的commit，而且revert不可以revert
merge操作。那样，想回滚feature a,
大家将要找到a的五回提交的版本号，然后由于不是一而再的，分别revert。那会导致复杂到不想处理了。好在github给了方便的东西，PR提供了revert的机会。找到以前的PR。

只是，那纯属不是个好操作！

2. 推介的干活流程

造成上述现象的来头是因为个别异步编程决定的。因为各样人都足以随时间提交，最后合并起来的时候以提交时间戳来作为种类的依照，就会变成那样。由此，当需求交给的远程服务器的时候，要是能重写下commit的光阴为眼前光阴，然后push到服务端，历史就会连串到最终了。

2. 推荐的做事流程

以致上述场景的缘故是因为个别异步编程决定的。因为各类人都得以随时间提交，最后合并起来的时候以提交时间戳来作为连串的基于，就会化为那样。因而，当要求提交的中远距离服务器的时候，如果能重写下commit的年魅族当下岁月，然后push到服务端，历史就会系列到结尾了。

2.1 模拟用户C

C用户新下载代码。

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git c正克隆到 'c'...
remote: Counting objects: 28, done.
remote: Compressing objects: 100% (17/17), done.
remote: Total 28 (delta 8), reused 22 (delta 4), pack-reused 0
接收对象中: 100% (28/28), 5.90 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (8/8), 完成.
检查连接... 完成。

然后编辑，提交

$ cd c
$ git config user.name "C"
$ ls
a.txt  b.txt  readme.md  test.txt
$ vim c.txt
$ git add .
$ git commit -m "C write one"
[master cf3f757] C write one
 1 file changed, 2 insertions(+)
 create mode 100644 c.txt

2.1 模拟用户C

C用户新下载代码。

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git c正克隆到 'c'...
remote: Counting objects: 28, done.
remote: Compressing objects: 100% (17/17), done.
remote: Total 28 (delta 8), reused 22 (delta 4), pack-reused 0
接收对象中: 100% (28/28), 5.90 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (8/8), 完成.
检查连接... 完成。

下一场编辑，提交

$ cd c
$ git config user.name "C"
$ ls
a.txt  b.txt  readme.md  test.txt
$ vim c.txt
$ git add .
$ git commit -m "C write one"
[master cf3f757] C write one
 1 file changed, 2 insertions(+)
 create mode 100644 c.txt

2.2 模拟用户D

与此同时，D也须求开发新feature

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git d正克隆到 'd'...
remote: Counting objects: 28, done.
remote: Compressing objects: 100% (17/17), done.
remote: Total 28 (delta 8), reused 22 (delta 4), pack-reused 0
接收对象中: 100% (28/28), 5.90 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (8/8), 完成.
检查连接... 完成。
$ cd d
/d$ git config user.name "D"
/d$ vim d.txt
/d$ git add .
/d$ git commit -m "d write one"
[master db7a6e9] d write one
 1 file changed, 1 insertion(+)
 create mode 100644 d.txt

2.2 模拟用户D

还要，D也必要开发新feature

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git d正克隆到 'd'...
remote: Counting objects: 28, done.
remote: Compressing objects: 100% (17/17), done.
remote: Total 28 (delta 8), reused 22 (delta 4), pack-reused 0
接收对象中: 100% (28/28), 5.90 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (8/8), 完成.
检查连接... 完成。
$ cd d
/d$ git config user.name "D"
/d$ vim d.txt
/d$ git add .
/d$ git commit -m "d write one"
[master db7a6e9] d write one
 1 file changed, 1 insertion(+)
 create mode 100644 d.txt

2.3 C继续支付

$ vim c.txt
$ git add .
$ git commit -m "c write two"
[master 01b1210] c write two
 1 file changed, 1 insertion(+)

2.3 C继续支付

$ vim c.txt
$ git add .
$ git commit -m "c write two"
[master 01b1210] c write two
 1 file changed, 1 insertion(+)

2.4 D继续支付

/d$ vim d.txt
/d$ git add .
/d$ git commit -m "d write two"
[master a1371e4] d write two
 1 file changed, 1 insertion(+)

2.4 D继续支付

/d$ vim d.txt
/d$ git add .
/d$ git commit -m "d write two"
[master a1371e4] d write two
 1 file changed, 1 insertion(+)

2.5 C 提交

$ vim c.txt 
$ git add .
$ git commit -m "c write three"
[master 13b7dde] c write three
 1 file changed, 1 insertion(+)

C开发截至，提交到长途

$ git status
位于分支 master
您的分支领先 'origin/master' 共 3 个提交。
  （使用 "git push" 来发布您的本地提交）
无文件要提交，干净的工作区
$ git push origin master:C
对象计数中: 9, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (6/6), 完成.
写入对象中: 100% (9/9), 750 bytes | 0 bytes/s, 完成.
Total 9 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> C

2.5 C 提交

$ vim c.txt 
$ git add .
$ git commit -m "c write three"
[master 13b7dde] c write three
 1 file changed, 1 insertion(+)

C开发为止，提交到长途

$ git status
位于分支 master
您的分支领先 'origin/master' 共 3 个提交。
  （使用 "git push" 来发布您的本地提交）
无文件要提交，干净的工作区
$ git push origin master:C
对象计数中: 9, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (6/6), 完成.
写入对象中: 100% (9/9), 750 bytes | 0 bytes/s, 完成.
Total 9 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> C

2.6 C 提PR

然后，create a Pull Request.

2.6 C 提PR

然后，create a Pull Request.

2.7 C修改再push

然后，发现还有个bug要修复，再度修改提交到远程C

$ vim c.txt 
$ git add .
$ git commit -m "C finish something else"
[master 2c5ff94] C finish something else
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git push origin master:C
对象计数中: 3, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (3/3), 完成.
写入对象中: 100% (3/3), 301 bytes | 0 bytes/s, 完成.
Total 3 (delta 1), reused 0 (delta 0)
remote: Resolving deltas: 100% (1/1), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
   13b7dde..2c5ff94  master -> C

2.7 C修改再push

然后，发现还有个bug要修复，再度修改提交到远程C

$ vim c.txt 
$ git add .
$ git commit -m "C finish something else"
[master 2c5ff94] C finish something else
 1 file changed, 1 insertion(+), 1 deletion(-)
$ git push origin master:C
对象计数中: 3, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (3/3), 完成.
写入对象中: 100% (3/3), 301 bytes | 0 bytes/s, 完成.
Total 3 (delta 1), reused 0 (delta 0)
remote: Resolving deltas: 100% (1/1), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
   13b7dde..2c5ff94  master -> C

2.8 C发现提交次数过多，历史太乱，合并一些历史

此时，发现一个题材，由于C在支付进程中提交了累累，而那三回提交的message其实没有多大意思，只是因为C可能为了保存代码，也可能是暂存。由此可见，C的前3次提交的message的意思其实是平等的，都是制造C文件，都是一个主旨，那么为了掩护历史的根本。最好把那3条信息统一成一条C create file c.txt。

参考git
合并历史，我们必要将3次历史合并成浮现为一回。

查看git历史，找到必要统一的起始区间

$ git log --oneline
2c5ff94 C finish something else
13b7dde c write three
01b1210 c write two
cf3f757 C write one
7151f4c 记录操作。
0bfe562 Merge pull request #2 from Ryan-Miao/b_remote
d81ce20 Merge remote-tracking branch 'origin/master' into b
2d74cfb Merge pull request #1 from Ryan-Miao/a
b90a3dd write three
4b1629e a write two
3f30f41 b write two
847078e b write one
53ff45e one
dae77d6 init

眼看，是要联合cf3f757到13b7dde。那么找到前一个的版本号为7151f4c

git rebase - i 7151f4c

下一场进入互相界面，因为我们想要把第3次和第2次以及第1次提交音信统一。将第3次的品类修改为squash,
意思是和第2次联合。然后将第2次的项目修改为squash,
同样是指合并的前一个commit。

差异git的相互略有分化，在此之前在windows上的git
bash是截然按照vim的指令修改的。这一次测试基于Ubuntu，发现存档命令为ctel + X。确认后进入下一个界面，合并3次提交后要求一个message

除去或者anyway you like，更改message。存档。完结。

$ git rebase -i 7151f4c
[分离头指针 e3764c5] c create  file c.txt
 Date: Fri Oct 20 22:06:24 2017 +0800
 1 file changed, 4 insertions(+)
 create mode 100644 c.txt
Successfully rebased and updated refs/heads/master.

Tips
当在rebase进程中出现了失误，可以使用git rebase --abort回去初步状态。即使发现争辨，则足以缓解争论，然后git rebase --continue .

类似已有 rebase-merge 目录，我难以置信你正处在其余一个变基操作
进度中。假如是这么，请执行
git rebase (–continue | –abort | –skip)
如果不是那般，请执行
rm -fr “/home/ryan/temp/c/.git/rebase-merge”
下一场再重新履行变基操作。为防止丢失首要数据，我曾经告一段落当前操作。

那时候，查看log，鲜明，C的那四次提交已经联合了。

$ git log --oneline
50b9fe9 C finish something else
e3764c5 c create  file c.txt
7151f4c 记录操作。
0bfe562 Merge pull request #2 from Ryan-Miao/b_remote
d81ce20 Merge remote-tracking branch 'origin/master' into b
2d74cfb Merge pull request #1 from Ryan-Miao/a
b90a3dd write three
4b1629e a write two
3f30f41 b write two
847078e b write one
53ff45e one
dae77d6 init

2.8 C发现提交次数过多，历史太乱，合并一些历史

那儿，发现一个难点，由于C在开发进度中付出了往往，而那三次提交的message其实没有多大意思，只是因为C可能为了保留代码，也说不定是暂存。可想而知，C的前3次提交的message的意义其实是一样的，都是创办C文件，都是一个宗旨，那么为了尊敬历史的绝望。最好把那3条音讯统一成一条C create file c.txt。

参考git
合并历史，大家须求将3次历史合并成浮现为两回。

查看git历史，找到必要联合的开场区间

$ git log --oneline
2c5ff94 C finish something else
13b7dde c write three
01b1210 c write two
cf3f757 C write one
7151f4c 记录操作。
0bfe562 Merge pull request #2 from Ryan-Miao/b_remote
d81ce20 Merge remote-tracking branch 'origin/master' into b
2d74cfb Merge pull request #1 from Ryan-Miao/a
b90a3dd write three
4b1629e a write two
3f30f41 b write two
847078e b write one
53ff45e one
dae77d6 init

众目睽睽，是要合并cf3f757到13b7dde。那么找到前一个的版本号为7151f4c

git rebase - i 7151f4c

接下来进入彼此界面，因为大家想要把第3次和第2次以及第1次提交新闻统一。将第3次的品种修改为squash,
意思是和第2次联合。然后将第2次的体系修改为squash,
同样是指合并的前一个commit。

今非昔比git的竞相略有不相同，以前在windows上的git
bash是一心依据vim的一声令下修改的。本次测试基于Ubuntu，发现存档命令为ctel + X。确认后进入下一个界面，合并3次提交后必要一个message

剔除或者anyway you like，更改message。存档。完结。

$ git rebase -i 7151f4c
[分离头指针 e3764c5] c create  file c.txt
 Date: Fri Oct 20 22:06:24 2017 +0800
 1 file changed, 4 insertions(+)
 create mode 100644 c.txt
Successfully rebased and updated refs/heads/master.

Tips
当在rebase进程中出现了失误，可以运用git rebase --abort归来起先状态。若是发现争执，则足以化解争持，然后git rebase --continue .

好像已有 rebase-merge 目录，我猜忌你正处在此外一个变基操作
进程中。若是是这么，请执行
git rebase (–continue | –abort | –skip)
只要不是那般，请执行
rm -fr “/home/ryan/temp/c/.git/rebase-merge”
然后再另行履行变基操作。为防止丢失紧要数据，我早就终止当前操作。

此刻，查看log，鲜明，C的本次提交已经统一了。

$ git log --oneline
50b9fe9 C finish something else
e3764c5 c create  file c.txt
7151f4c 记录操作。
0bfe562 Merge pull request #2 from Ryan-Miao/b_remote
d81ce20 Merge remote-tracking branch 'origin/master' into b
2d74cfb Merge pull request #1 from Ryan-Miao/a
b90a3dd write three
4b1629e a write two
3f30f41 b write two
847078e b write one
53ff45e one
dae77d6 init

2.9 C再次push

事先的push已经不可以用了。须要开新支行推送过去。因为 rebase
只好在地点分支做。不要改动公共分支。

$ git push origin master:C
To git@github.com:Ryan-Miao/l4git-workflow.git
 ! [rejected]        master -> C (non-fast-forward)
error: 无法推送一些引用到 'git@github.com:Ryan-Miao/l4git-workflow.git'
提示：更新被拒绝，因为推送的一个分支的最新提交落后于其对应的远程分支。
提示：检出该分支并整合远程变更（如 'git pull ...'），然后再推送。详见
提示：'git push --help' 中的 'Note about fast-forwards' 小节。

选料推送的新分支C2

$ git push origin master:C2
对象计数中: 6, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (5/5), 完成.
写入对象中: 100% (6/6), 569 bytes | 0 bytes/s, 完成.
Total 6 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> C2

开立异的PR

2.9 C再次push

事先的push已经不可能用了。要求开新支行推送过去。因为 rebase
只好在地头分支做。不要改动公共分支。

$ git push origin master:C
To git@github.com:Ryan-Miao/l4git-workflow.git
 ! [rejected]        master -> C (non-fast-forward)
error: 无法推送一些引用到 'git@github.com:Ryan-Miao/l4git-workflow.git'
提示：更新被拒绝，因为推送的一个分支的最新提交落后于其对应的远程分支。
提示：检出该分支并整合远程变更（如 'git pull ...'），然后再推送。详见
提示：'git push --help' 中的 'Note about fast-forwards' 小节。

拔取推送的新分支C2

$ git push origin master:C2
对象计数中: 6, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (5/5), 完成.
写入对象中: 100% (6/6), 569 bytes | 0 bytes/s, 完成.
Total 6 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> C2

成立新的PR

2.10 新的merge方式： rebase

通过初始的平凡流程发现，每一次merge的时候，都会多出一条新的交付音讯，那让历史看起来很想得到。那么，可以选用rebase到master，变基，就是重新以master为骨干，把近日的交由直接移动到master的末尾。不会因为提交时间的离散导致多次commit的message被拆开。
选取 rebase and merge

那时，可以看来C提交的三回新闻都是新型的，没有暴发交叉。而且也未曾发生多余的merge消息。

有人会问，那么岂不是看不到PR的地方了。点开C的野史。可以看到message下方是有PR的号子的：

对了，刚起先的PR要记得close

2.10 新的merge方式： rebase

通过起先的平凡流程发现，每便merge的时候，都会多出一条新的提交音信，那让历史看起来很想得到。那么，可以采纳rebase到master，变基，就是重新以master为大旨，把近期的交给直接移动到master的末端。不会因为提交时间的离散导致数十次commit的message被拆开。
选用 rebase and merge

那时，可以见见C提交的一遍音讯都是最新的，没有生出交叉。而且也远非发生多余的merge新闻。

有人会问，那么岂不是看不到PR的地方了。点开C的历史。可以见见message下方是有PR的号子的：

对了，刚伊始的PR要记得close

2.11 那时候D也不负众望了

/d$ git push origin master:D
对象计数中: 10, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (7/7), 完成.
写入对象中: 100% (10/10), 4.49 KiB | 0 bytes/s, 完成.
Total 10 (delta 2), reused 4 (delta 1)
remote: Resolving deltas: 100% (2/2), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> D

提PR，这时候，假设应用merge：

结果肯定发现，1）
d提交message被依据时间分散插入历史了(被插入到c的历史此前)，
2）多了一遍 Merge pull request #5 from Ryan-Miao/D..的提交信息。同初阶所述一样，历史开端变得一塌糊涂了。那么，那种题材如何做吧？

2.11 那时候D也成就了

/d$ git push origin master:D
对象计数中: 10, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (7/7), 完成.
写入对象中: 100% (10/10), 4.49 KiB | 0 bytes/s, 完成.
Total 10 (delta 2), reused 4 (delta 1)
remote: Resolving deltas: 100% (2/2), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> D

提PR，那时候，假使选取merge：

结果肯定发现，1）
d提交message被按照时间分散插入历史了(被插入到c的野史此前)，
2）多了三回 Merge pull request #5 from Ryan-Miao/D..的交给消息。同早先所述一样，历史开首变得一无可取了。那么，那种难题如何做呢？

2.12 提交前rebase

就像是C
rebase后merge到master一样。我们一样能够在地点做到那样的事情。在地面rebase，让我们此次feature的交付全体插到master节点从此，有序，而且不难revert。
此次，以新的E和F交叉commit为例子，最后将取得各自分离的野史

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git e
正克隆到 'e'...
remote: Counting objects: 52, done.
remote: Compressing objects: 100% (33/33), done.
remote: Total 52 (delta 18), reused 36 (delta 7), pack-reused 0
接收对象中: 100% (52/52), 7.91 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (18/18), 完成.
检查连接... 完成。

$ cd e
/e$ vim e.txt
/e$ git add .
/e$ git config user.name "E"
/e$ git commit -m "e commit one"
[master 77ecd73] e commit one
 1 file changed, 1 insertion(+)
 create mode 100644 e.txt

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git f
正克隆到 'f'...
remote: Counting objects: 52, done.
remote: Compressing objects: 100% (33/33), done.
remote: Total 52 (delta 18), reused 36 (delta 7), pack-reused 0
接收对象中: 100% (52/52), 7.91 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (18/18), 完成.
检查连接... 完成。

$ cd f
$ vim f.txt
$ git config user.name "F"
$ git add .
$ git commit -m "d write one"
[master b41f8c5] d write one
 1 file changed, 2 insertions(+)
 create mode 100644 f.txt

/e$ vim e.txt
/e$ git add .
/e$ git commit -m "e write two"
[master 2b8c9fb] e write two
 1 file changed, 1 insertion(+)

$ vim f.txt
$ git add .
$ git commit -m "f write two"
[master de9051b] f write two
 1 file changed, 1 insertion(+)

/e$ vim e.txt 
/e$ git add .
/e$ git commit -m "e write three"
[master b1b9f6e] e write three
 1 file changed, 2 insertions(+)

此刻，e完毕了，须求交给。提交前先rebase：

/e$ git fetch
/e$ git rebase origin/master
当前分支 master 是最新的。

然后，再提交

/e$ git push origin master:E
对象计数中: 9, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (6/6), 完成.
写入对象中: 100% (9/9), 753 bytes | 0 bytes/s, 完成.
Total 9 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> E

然后， PR, merge.

同样F:

$ git status
位于分支 master
您的分支领先 'origin/master' 共 2 个提交。
  （使用 "git push" 来发布您的本地提交）
无文件要提交，干净的工作区
$ git fetch 
remote: Counting objects: 12, done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 12 (delta 6), reused 6 (delta 3), pack-reused 0
展开对象中: 100% (12/12), 完成.
来自 github.com:Ryan-Miao/l4git-workflow
   24c6818..f36907c  master     -> origin/master
 * [新分支]          E          -> origin/E
$ git rebase origin/master
首先，回退分支以便在上面重放您的工作...
应用：d write one
应用：f write two

$ git push origin master:F
对象计数中: 6, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (4/4), 完成.
写入对象中: 100% (6/6), 515 bytes | 0 bytes/s, 完成.
Total 6 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> F

PR， rebase and merge。那时候看history：

依据前五遍的做法，E和F交叉在本土提交，每趟commit的小时戳也是交叉，最后合并到master的时候，历史并不曾被拆卸。而是像咱们期望的一样，顺序下来。那才是大家想要的。通过看图形化界面也能看到分化：

蓝色的线是master

那就是说，操作便是fetch-》rebase。事实上，可以二合一为：

git pull --rebase origin master

2.12 提交前rebase

就如C
rebase后merge到master一样。大家同样可以在该地做到那样的事情。在地点rebase，让我们此次feature的交付全部插到master节点之后，有序，而且简单revert。
这一次，以新的E和F交叉commit为例子，最后将赢得各自分离的历史

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git e
正克隆到 'e'...
remote: Counting objects: 52, done.
remote: Compressing objects: 100% (33/33), done.
remote: Total 52 (delta 18), reused 36 (delta 7), pack-reused 0
接收对象中: 100% (52/52), 7.91 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (18/18), 完成.
检查连接... 完成。

$ cd e
/e$ vim e.txt
/e$ git add .
/e$ git config user.name "E"
/e$ git commit -m "e commit one"
[master 77ecd73] e commit one
 1 file changed, 1 insertion(+)
 create mode 100644 e.txt

$ git clone git@github.com:Ryan-Miao/l4git-workflow.git f
正克隆到 'f'...
remote: Counting objects: 52, done.
remote: Compressing objects: 100% (33/33), done.
remote: Total 52 (delta 18), reused 36 (delta 7), pack-reused 0
接收对象中: 100% (52/52), 7.91 KiB | 0 bytes/s, 完成.
处理 delta 中: 100% (18/18), 完成.
检查连接... 完成。

$ cd f
$ vim f.txt
$ git config user.name "F"
$ git add .
$ git commit -m "d write one"
[master b41f8c5] d write one
 1 file changed, 2 insertions(+)
 create mode 100644 f.txt

/e$ vim e.txt
/e$ git add .
/e$ git commit -m "e write two"
[master 2b8c9fb] e write two
 1 file changed, 1 insertion(+)

$ vim f.txt
$ git add .
$ git commit -m "f write two"
[master de9051b] f write two
 1 file changed, 1 insertion(+)

/e$ vim e.txt 
/e$ git add .
/e$ git commit -m "e write three"
[master b1b9f6e] e write three
 1 file changed, 2 insertions(+)

那会儿，e落成了，需求提交。提交前先rebase：

/e$ git fetch
/e$ git rebase origin/master
当前分支 master 是最新的。

然后，再提交

/e$ git push origin master:E
对象计数中: 9, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (6/6), 完成.
写入对象中: 100% (9/9), 753 bytes | 0 bytes/s, 完成.
Total 9 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> E

然后， PR, merge.

同样F:

$ git status
位于分支 master
您的分支领先 'origin/master' 共 2 个提交。
  （使用 "git push" 来发布您的本地提交）
无文件要提交，干净的工作区
$ git fetch 
remote: Counting objects: 12, done.
remote: Compressing objects: 100% (6/6), done.
remote: Total 12 (delta 6), reused 6 (delta 3), pack-reused 0
展开对象中: 100% (12/12), 完成.
来自 github.com:Ryan-Miao/l4git-workflow
   24c6818..f36907c  master     -> origin/master
 * [新分支]          E          -> origin/E
$ git rebase origin/master
首先，回退分支以便在上面重放您的工作...
应用：d write one
应用：f write two

$ git push origin master:F
对象计数中: 6, 完成.
Delta compression using up to 4 threads.
压缩对象中: 100% (4/4), 完成.
写入对象中: 100% (6/6), 515 bytes | 0 bytes/s, 完成.
Total 6 (delta 2), reused 0 (delta 0)
remote: Resolving deltas: 100% (2/2), completed with 1 local object.
To git@github.com:Ryan-Miao/l4git-workflow.git
 * [new branch]      master -> F

PR， rebase and merge。那时候看history：

安分守纪前两次的做法，E和F交叉在地面提交，每趟commit的年月戳也是陆续，最后合并到master的时候，历史并从未被拆开。而是像大家期待的一模一样，顺序下来。那才是大家想要的。通过看图形化界面也能看到不同：

黄色的线是master

那就是说，操作便是fetch-》rebase。事实上，可以二合一为：

git pull --rebase origin master

最终结果

在都没交给到server的时候，
历史是散落在各种开发者的地点，但commit时间有程序。

按照rebase的用法，提交前rebase五回，就可以使得一个feature的付出串联到一块

终极在github的commit看起来也就是百步穿杨的多

末段结出

在都没交给到server的时候，
历史是分散在一一开发者的地点，但commit时间井井有理。

按照rebase的用法，提交前rebase一遍，就足以使得一个feature的提交串联到一同

最终在github的commit看起来也就是贯虱穿杨的多

旗帜

想维持树的净化，方法就是：在git push以前，先git fetch，再git
rebase。

git fetch origin master
git rebase origin/master
git push

或者

git pull --rebase origin master

若果您把变基命令当作是在推送前清理提交使之整洁的工具，并且只在一贯不推送至共用仓库的提交上进行变基命令，就不会有事。
如若在这么些早已被推送至共用仓库的交付上执行变基命令，并据此丢掉了一部分别人的支出所按照的付出，那你就有大麻烦了，你的同事也会因而看不起你。

倘若你或你的同事在好几情状下决定要这样做，请一定要通告每个人执行 git
pull –rebase 命令，那样即便不可以幸免伤痛，但能抱有缓解。

相对不要在集体(远程分支)上rebase，也就是说，如若没有必要就绝不在github
merge的时候接纳rebase，而是用上述的章程，在本土自己的支行推送前rebase
纯属不可以在公共分支上reset，也毫无用–force
独立效能的往往提交要学会联合提交，保持提交的简短。
付出message尽量能概括修改内容。

规范

想维持树的清爽，方法就是：在git push以前，先git fetch，再git
rebase。

git fetch origin master
git rebase origin/master
git push

或者

git pull --rebase origin master

若是您把变基命令当作是在推送前清理提交使之整洁的工具，并且只在未曾推送至共用仓库的交付上执行变基命令，就不会有事。
假设在这个早已被推送至共用仓库的付出上实施变基命令，并就此丢掉了一些别人的支出所依照的提交，那你就有大麻烦了，你的同事也会因而看不起你。

借使您或你的同事在少数情形下决定要那样做，请一定要通报每个人实施 git
pull –rebase 命令，这样固然不可以防止伤痛，但能抱有缓解。

相对不用在公私(远程分支)上rebase，也就是说，如若没有要求就不用在github
merge的时候拔取rebase，而是用上述的主意，在本土自己的分段推送前rebase
纯属不得以在集体分支上reset，也无须用–force
独自作用的屡屡付给要学会联合提交，保持提交的简练。
付出message尽量能概括修改内容。

一贯在动用git做版本控制，向来在拔取git做版本控制

目录

目录

前言

前言

学习git工作流

学习git工作流

1. 最简便的利用，不推荐

1. 最简易的施用，不推荐

1.1.创设仓库

1.1.创办仓库

1.2. 模仿用户A

1.2. 模仿用户A

1.3. 仿照用户B

1.3. 效仿用户B

1.4. 模拟用户A

1.4. 仿照用户A

1.5. 模仿用户C

1.5. 模拟用户C

1.6. 仿照用户B

1.6. 仿照用户B

1.7. 模仿用户C

1.7. 仿照用户C

2. 推介的干活流程

2. 推荐的做事流程

2.1 模拟用户C

2.1 模拟用户C

2.2 模拟用户D

2.2 模拟用户D

2.3 C继续支付

2.3 C继续支付

2.4 D继续支付

2.4 D继续支付

2.5 C 提交

2.5 C 提交

2.6 C 提PR

2.6 C 提PR

2.7 C修改再push

2.7 C修改再push

2.8 C发现提交次数过多，历史太乱，合并一些历史

2.8 C发现提交次数过多，历史太乱，合并一些历史

2.9 C再次push

2.9 C再次push

2.10 新的merge方式： rebase

2.10 新的merge方式： rebase

2.11 那时候D也不负众望了

2.11 那时候D也成就了

2.12 提交前rebase

2.12 提交前rebase

最终结果

末段结出

旗帜

规范

参考来源

参照来源

相关文章