Git 工作流的不利打开方式。Git 工作流的不利打开方式。

一直在使用git做版本控制,一直在使用git做版本控制

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

转载: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
末段结出

图片 1

图片 2

前言

一直于以git做版本控制,也一直工作深顺利,直到与人家发生冲突的早晚。这才注意到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。

图片 3

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。

图片 4

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 如下:

图片 5

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 如下:

图片 6

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如下
图片 7

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如下
图片 8

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

图片 9
图片 10

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

图片 11
图片 12

1.5. 仿用户C

C review the PR and then merged it.

图片 13
这,github的史如下:
图片 14
得看到,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.

图片 15
此时,github的史如下:
图片 16
足见到,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看起有些乱。如下:
图片 17
给人感觉混乱的是b原来的历史只有和睦的交由,更新了master到当地后,历史记录被插了master中的历史。于是,发现原自己根本的历史被中插多次commit。甚至有数不成merge
master的日记显得又增长又碍眼。但不管怎么说,B还是使交给的。

遂,B提交至长途分支b:
图片 18

1.6. 拟用户B

用户B提至前先行pull master,更新最新的代码到地方,防止冲突。

 git fetch
 git merge origin/master

这儿log看起有点乱。如下:
图片 19
受人发混乱的凡b原来的历史只有自己之付出,更新了master到本地后,历史记录被插入了master中之史。于是,发现原先好到底的史为中间插多次commit。甚至个别不成merge
master的日志显得又加上同时碍眼。但不管怎么说,B还是一旦提交的。

于是乎,B提交至长途分支b:
图片 20

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。
下一场,项目历史就变成了这般:

图片 21

一眼大概看起还好,每次都能够望提交历史,只要非是message写的专门少,差不多可以清楚最近交的情节。然而,仔细一看,顺序好像不对。目前凡两个feature,但历史却远超2单。没关系,保证细粒度更易反映开发进度。然而,这些历史并无是本feature的揭示顺序,那么,当我怀念如果找到feature
a的下即便很麻烦串联起。如果commit足够多,时间跨度足够大,甚至向看不出来feature
a到底做了怎么修改。

这儿想要运图形化git 历史工具来增援了解历史:
图片 22

此地,还吓,还勉强能够观看走向。但当10独多民用而出来说,线简直不可知看了,时间跨度足够好的语,线为看无结束。

因此,这种模式,正是我们团结时运的模式。差评。这尚非到底了,后面更老之困顿来了。最先发布的feature
a出了问题,必须回滚。怎么做到。关于回滚,就是其余一个话题了。
但我们该掌握用revert而不是reset.
但revert只能回滚指定的commit,或者连续的commit,而且revert不可知revert
merge操作。这样,想回滚feature a,
我们且找到a的几糟提交的版号,然后由不是连连的,分别revert。这会招致复杂到非思量处理了。好当github给了有利于之东西,PR提供了revert的时机。找到以前的PR。

图片 23

不过,这纯属不是独好操作!


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。
下一场,项目历史就是成为了这样:

图片 24

一眼大概看起还吓,每次都能够看到提交历史,只要非是message写的特别少,差不多得理解最近交由的情节。然而,仔细一看,顺序好像不对。目前一共两个feature,但历史却远超过2只。没关系,保证细粒度更易反映开发进度。然而,这些历史并无是仍feature的宣布顺序,那么,当自己眷恋如果找到feature
a的上就是挺不便串联起。如果commit足够多,时间跨度足够深,甚至从看不出来feature
a到底做了什么样修改。

此时想要利用图形化git 历史工具来赞助了解历史:
图片 25

此处,还吓,还勉强能够看到走向。但当10独多私而开发来说,线简直不克看了,时间跨度足够大的讲话,线为看无收。

从而,这种模式,正是我们协调眼前以的模式。差评。这尚未算是完,后面更要命的艰苦来了。最先发布之feature
a出了问题,必须回滚。怎么好。关于回滚,就是另一个话题了。
但我们应有明白用revert而不是reset.
但revert只能回滚指定的commit,或者连续的commit,而且revert不克revert
merge操作。这样,想回滚feature a,
我们就要找到a的几乎次等提交的版号,然后由未是连的,分别revert。这会造成复杂到无思处理了。好于github给了利之物,PR提供了revert的会。找到以前的PR。

图片 26

可,这绝不是独好操作!


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.
图片 27

2.6 C 提PR

然后,create a Pull Request.
图片 28

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

旗帜鲜明,是只要合并cf3f75713b7dde。那么找到前一个之版本号为7151f4c

git rebase - i 7151f4c

然后进相互界面,因为我们怀念如果将第3浅以及第2浅以及第1破提交信息统一。将第3糟的种修改也squash,
意思是与第2赖合。然后用第2潮的路修改为squash,
同样是凭借合之面前一个commit。
图片 29
不等git的相略有不同,之前在windows上的git
bash是截然以vim的通令修改的。本次测试基于Ubuntu,发现存档命令为ctel + X。确认后登下一个界面,合并3不成提交后用一个message

图片 30

剔除或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

众目睽睽,是一旦统一cf3f75713b7dde。那么找到前一个底版本号为7151f4c

git rebase - i 7151f4c

接下来上相互界面,因为我们怀念只要拿第3不好同第2不好同第1不良提交信息统一。将第3不行的类别修改也squash,
意思是暨第2糟糕联。然后将第2蹩脚的门类修改为squash,
同样是恃合的面前一个commit。
图片 31
不同git的相略有不同,之前在windows上之git
bash是全然按照vim的指令修改的。本次测试基于Ubuntu,发现存档命令为ctel + X。确认后跻身下一个界面,合并3浅提交后需一个message

图片 32

剔除或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
图片 33

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
图片 34

2.10 新的merge方式: rebase

经过初步之常备流程发现,每次merge的早晚,都见面多起一致漫漫新的付出信息,这为历史看起挺奇怪。那么,可以选取rebase到master,变基,就是重复为master为中心,把目前之提交直接倒至master的后边。不见面为交时的离散导致多次commit的message被拆开。
选择 rebase and merge
图片 35

图片 36

这会儿,可以见到C提交的有限涂鸦信息都是新型的,没有有交叉。而且为从来不有多余的merge信息。
图片 37

有人会咨询,那么岂不是看不到PR的地点了。点开C的史。可以视message下方是产生PR的号的:
图片 38

对了,刚开头之PR要记close
图片 39

2.10 新的merge方式: rebase

经初步之家常流程发现,每次merge的下,都见面多有同长新的交信息,这吃历史看起老想得到。那么,可以选取rebase到master,变基,就是再为master为骨干,把当前之付出直接走及master的末尾。不见面以交时之离散导致多次commit的message被拆。
选择 rebase and merge
图片 40

图片 41

这时候,可以看看C提交的片差信息都是风靡的,没有发交叉。而且为不曾发生多余的merge信息。
图片 42

有人会咨询,那么岂不是看不到PR的地点了。点开C的史。可以看出message下方是出PR的号子的:
图片 43

对了,刚开头之PR要记close
图片 44

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:
图片 45

图片 46

结果必然发现,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:
图片 47

图片 48

结果肯定发现,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为例,最终将抱各自分离的史

E:

$ 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

F:

$ 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:

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

F:

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

E:

/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:

图片 49

依照前几乎次的做法,E和F交叉在地面提交,每次commit的工夫戳也是交叉,最终合并及master的时段,历史并没吃拆除。而是如咱要的平等,顺序下来。这才是咱怀念使之。通过看图形化界面也克观看区别:

绿色的丝是master
图片 50

这就是说,操作就是fetch-》rebase。事实上,可以二合一呢:

git pull --rebase origin master

图片 51

2.12 提交前rebase

尽管比如C
rebase后merge到master一样。我们一致好以地面就这样的政工。在地头rebase,让咱们此次feature的交全体栽到master节点下,有序,而且爱revert。
此次,以新的E和F交叉commit为例,最终用获各自分离的史

E:

$ 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

F:

$ 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:

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

F:

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

E:

/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:

图片 52

论前几乎不行的做法,E和F交叉在地面提交,每次commit的时间戳也是穿插,最终合并及master的上,历史并无被拆除。而是如我们希望的平等,顺序下来。这才是咱们怀念使的。通过看图形化界面也克观看区别:

绿色的丝是master
图片 53

那么,操作就是fetch-》rebase。事实上,可以二合一呢:

git pull --rebase origin master

图片 54

末尾结果

当还无交给到server的下,
历史是散于各个开发者的地头,但commit时间发生次序。
图片 55

按照rebase的用法,提交前rebase一样不好,就足以使一个feature的提交串联到一块儿
图片 56

末段在github的commit看起呢不怕是一帆风顺的基本上
图片 57

末了结出

当都并未交给至server的下,
历史是散在相继开发者的地方,但commit时间发次。
图片 58

按照rebase的用法,提交前rebase相同坏,就足以教一个feature的付出串联到一起
图片 59

末了于github的commit看起为便是顺风的大多
图片 60

规范

  1. 想念保树的洁净,方法就是:在git push之前,先git fetch,再git
    rebase。

git fetch origin master
git rebase origin/master
git push

或者

git pull --rebase origin master

若你把变基命令当作是于推送前清理提交使之洁的工具,并且就当并未推送至同用仓库的交由上实行变基命令,就非会见有事。
假如在那些已经被推送到一头用仓库的交付上实施变基命令,并据此丢掉了有人家的开销所根据的付出,那尔便发好累了,你的同事也会因此轻视你。

假若你要么你的同事在某些情形下决定要如此做,请一定要是通知每个人实行 git
pull –rebase 命令,这样尽管未克幸免伤痛,但能够拥有缓解。

  1. 断不用当国有(远程分支)上rebase,也就是说,如果没必要就不用在github
    merge的时段择rebase,而是用上述的法门,在本土自己之分层推送前rebase
  2. 断不可以于国有分支上reset,也毫不为此–force
  3. 独自功能的累付出要学会联合提交,保持提交的简单。
  4. 授message尽量能连修改内容。

  1. 相思保树的净,方法就是是:在git push之前,先git fetch,再git
    rebase。

git fetch origin master
git rebase origin/master
git push

或者

git pull --rebase origin master

设若您将变基命令当作是当推送前清理提交使的洁的家伙,并且仅以无推送到一头用仓库的付出上推行变基命令,就非会见有事。
假如在那些既给推送到同用仓库的交上实行变基命令,并据此丢掉了有的旁人的开销所依据的交给,那尔不怕发出酷累了,你的同事呢会见因此轻视你。

要你要你的同事在少数情形下决定要如此做,请一定要通知每个人实践 git
pull –rebase 命令,这样尽管未可知免伤痛,但亦可抱有缓解。

  1. 绝不用以官(远程分支)上rebase,也就是说,如果没必要就绝不当github
    merge的下选择rebase,而是用上述的方式,在地面自己的分层推送前rebase
  2. 切不可以在官分支上reset,也绝不用–force
  3. 单身功能的往往交由要学会联合提交,保持提交的简短。
  4. 交message尽量能连修改内容。

参照来源

  • https://git-scm.com/book/zh/v2/Git-%E5%88%86%E6%94%AF-%E5%8F%98%E5%9F%BA
  • https://github.com/geeeeeeeeek/git-recipes/wiki/3.5-%E5%B8%B8%E8%A7%81%E5%B7%A5%E4%BD%9C%E6%B5%81%E6%AF%94%E8%BE%83
  • https://git-scm.com/book/zh/v1/Git-%E5%B7%A5%E5%85%B7-%E9%87%8D%E5%86%99%E5%8E%86%E5%8F%B2
  • https://segmentfault.com/q/1010000000430041

参照来源

  • https://git-scm.com/book/zh/v2/Git-%E5%88%86%E6%94%AF-%E5%8F%98%E5%9F%BA
  • https://github.com/geeeeeeeeek/git-recipes/wiki/3.5-%E5%B8%B8%E8%A7%81%E5%B7%A5%E4%BD%9C%E6%B5%81%E6%AF%94%E8%BE%83
  • https://git-scm.com/book/zh/v1/Git-%E5%B7%A5%E5%85%B7-%E9%87%8D%E5%86%99%E5%8E%86%E5%8F%B2
  • https://segmentfault.com/q/1010000000430041