工作流的科学打开药格局ca88官方会员登录

转载: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
最终结出

ca88官方会员登录 1

ca88官方会员登录 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。

ca88官方会员登录 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。

ca88官方会员登录 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 如下:

ca88官方会员登录 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 如下:

ca88官方会员登录 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如下
ca88官方会员登录 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如下
ca88官方会员登录 8

1.4. 效仿用户A

A和B分别是在该地开发,所以这种顺序是大惑不解的,恐怕A比B先commit3次,可能B先commit3次。那里的顺序是指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

ca88官方会员登录 9
ca88官方会员登录 10

1.4. 仿照用户A

A和B分别是在地头开发,所以那种顺序是不解的,恐怕A比B先commit贰次,可能B先commit1次。那里的次第是指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

ca88官方会员登录 11
ca88官方会员登录 12

1.5. 效仿用户C

C review the PR and then merged it.

ca88官方会员登录 13
那时候,github的野史如下:
ca88官方会员登录 14
能够看到,merge的时候多了二次commit,message暗许为 Merge pull request #1 from Ryan-Miao/a...
方今看起来,只有a一位的历史记录,还算清楚,a做了二回提交。

1.5. 效仿用户C

C review the PR and then merged it.

ca88官方会员登录 15
那时,github的野史如下:
ca88官方会员登录 16
能够观望,merge的时候多了2回commit,message暗中同意为 Merge pull request #1 from Ryan-Miao/a...
于今看起来,只有a1人的历史记录,还算清楚,a做了三回提交。

1.6. 模仿用户B

用户B提交前先pull master,更新最新的代码到本地,防止争辩。

 git fetch
 git merge origin/master

此刻log看起来有点乱。如下:
ca88官方会员登录 17
令人深感混乱的是b原来的野史唯有团结的交由,更新了master到地头之后,历史记录被插入了master中的历史。于是,发现原来自个儿到底的历史被中间插入数十次commit。甚至三次merge
master的日记显得又长又碍眼。但不管怎么说,B依旧要提交的。

于是乎,B提交到长途分支b:
ca88官方会员登录 18

1.6. 效仿用户B

用户B提交前先pull master,更新最新的代码到地头,幸免冲突。

 git fetch
 git merge origin/master

此刻log看起来有点乱。如下:
ca88官方会员登录 19
令人感觉混乱的是b原来的历史唯有团结的付出,更新了master到地头之后,历史记录被插入了master中的历史。于是,发现原来自身根本的野史被中间插入很多次commit。甚至四次merge
master的日志显得又长又碍眼。但不管怎么说,B如故要交给的。

于是,B提交到长途分支b:
ca88官方会员登录 20

1.7. 模拟用户C

此时,A达成了feature a,然后提了PSportage,然后找旁人C
merge了。而后,B也实现了feature b,提了PLacrosse,必要review and merge。 C
review之后,approved, 然后D review, D merge。

此刻,项目基本走上标准。feature二个1个加上进去,重复在此以前的干活流程:
fetch -》 work -》 commit -》 push -》 P翼虎 -》 merged。
下一场,项目历史就成为了这样:

ca88官方会员登录 21

一眼差不多看起来幸而,每一回都能看到提交历史,只要不是message写的尤其少,差不离能够了解近年来亲交配给的情节。然则,仔细一看,顺序好像不对。近年来合计五个feature,但历史却远远当先一个。没关系,保险细粒度更易于反映开发进度。但是,那些历史并不是遵纪守法feature的通知顺序,那么,当自己想要找到feature
a的时候就很难串联起来。假若commit丰裕多,时间跨度丰富大,甚至一直看不出来feature
a到底做了什么样修改。

那时候想要使用图形化git 历史工具来赞助精通历史:
ca88官方会员登录 22

此间,辛亏,还勉强能观望走向。但当13个广大个人同时开发以来,线俨然不能够看了,时间跨度足够大的话,线也看不完。

故此,那种方式,便是我们团结日前利用的形式。差评。那还不算完,前边更大的难堪来了。初叶发布的feature
a出了难题,必须回滚。如何是好到。关于回滚,便是另三个话题了。
但我们应有清楚使用revert而不是reset.
但revert只好回滚内定的commit,只怕三番五次的commit,而且revert无法revert
merge操作。那样,想回滚feature a,
大家将要找到a的五次提交的版本号,然后由于不是延续的,分别revert。那会造成复杂到不想处理了。辛亏github给了有益的东西,P兰德CR-V提供了revert的机遇。找到在此之前的P奥德赛。

ca88官方会员登录 23

而是,那相对不是个好操作!


1.7. 模仿用户C

这时候,A达成了feature a,然后提了P索罗德,然后找旁人C
merge了。而后,B也完毕了feature b,提了P奇骏,供给review and merge。 C
review之后,approved, 然后D review, D merge。

此时,项目为主走上专业。feature3个3个增加进去,重复之前的劳作流程:
fetch -》 work -》 commit -》 push -》 PMurano -》 merged。
然后,项目历史就变成了这么:

ca88官方会员登录 24

一眼大约看起来幸好,每回都能看出提交历史,只要不是message写的专门少,大致能够精通方今付出的内容。不过,仔细一看,顺序好像不对。近来合计四个feature,但历史却远远超越贰个。没关系,有限援助细粒度更便于反映开发进程。可是,那些历史并不是服从feature的昭示顺序,那么,当笔者想要找到feature
a的时候就很难串联起来。假诺commit丰硕多,时间跨度丰裕大,甚至根本看不出来feature
a到底做了怎样修改。

那时候想要使用图形化git 历史工具来支援了然历史:
ca88官方会员登录 25

那边,万幸,还勉强能观望走向。但当十三个广大个人同时开发以来,线简直不能够看了,时间跨度丰富大的话,线也看不完。

故此,那种方式,就是大家团结近来选择的格局。差评。这还不算完,后边更大的不方便来了。起先宣布的feature
a出了难点,必须回滚。怎么完成。关于回滚ca88官方会员登录,,正是另二个话题了。
但大家应该驾驭使用revert而不是reset.
但revert只可以回滚钦定的commit,或然一而再的commit,而且revert不能够revert
merge操作。那样,想回滚feature a,
大家将要找到a的两次提交的本子号,然后由于不是一连的,分别revert。那会促成复杂到不想处理了。幸亏github给了方便的事物,P卡宴提供了revert的机会。找到从前的P奥德赛。

ca88官方会员登录 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.
ca88官方会员登录 27

2.6 C 提PR

然后,create a Pull Request.
ca88官方会员登录 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发现提交次数过多,历史太乱,合并一些历史

此刻,发现2个题材,由于C在付出过程中提交了频仍,而那两回提交的message其实没有多马虎理,只是因为C或然为了保存代码,也大概是暂存。同理可得,C的前2回提交的message的含义其实是同一的,都以成立C文件,都以几个主旨,那么为了珍爱历史的一尘不到。最好把那3条音信统一成一条C create file c.txt

参考git
合并历史
,大家要求将二次历史合并成展示为二回。

翻开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。那么找到前2个的版本号为7151f4c

git rebase - i 7151f4c

接下来进入互相界面,因为大家想要把第一回和第三次以及第二遍提交新闻统一。将第②回的连串修改为squash,
意思是和第二次联合。然后将第3回的门类修改为squash,
同样是指合并的前贰个commit。
ca88官方会员登录 29
差异git的互动略有不一致,在此以前在windows上的git
bash是一点一滴依照vim的吩咐修改的。本次测试基于Ubuntu,发现存档命令为ctel + X。确认后跻身下3个界面,合并三次提交后必要三个message

ca88官方会员登录 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的前2遍提交的message的含义其实是一模一样的,都以创造C文件,都以1个宗旨,那么为了保证历史的一尘不到。最好把这3条音讯统玖分一条C create file c.txt

参考git
合并历史
,大家须求将1次历史合并成突显为2遍。

查阅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次和第②次以及第3次提交音信统一。将第四回的品种修改为squash,
意思是和第③次联合。然后将第②次的种类修改为squash,
同样是指合并的前2个commit。
ca88官方会员登录 31
差别git的互动略有差异,在此之前在windows上的git
bash是全然依据vim的吩咐修改的。本次测试基于Ubuntu,发现存档命令为ctel + X。确认后进入下贰个界面,合并3回提交后必要五个message

ca88官方会员登录 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的那1回提交已经联合了。

$ 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

成立新的PEnclave
ca88官方会员登录 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

始建新的PCRUISER
ca88官方会员登录 34

2.10 新的merge方式: rebase

由此初叶的不乏先例流程发现,每便merge的时候,都会多出一条新的交给消息,那让历史看起来很奇怪。那么,能够采纳rebase到master,变基,就是重复以master为主导,把方今的提交直接移动到master的前边。不会因为提交时间的离散导致多次commit的message被拆散。
选用 rebase and merge
ca88官方会员登录 35

ca88官方会员登录 36

这儿,能够见到C提交的两次音讯都是风靡的,没有生出交叉。而且也未曾产生多余的merge音讯。
ca88官方会员登录 37

有人会问,那么岂不是看不到P昂Cora的地址了。点开C的历史。能够见到message下方是有PKoleos的号子的:
ca88官方会员登录 38

对了,刚起头的P翼虎要记得close
ca88官方会员登录 39

2.10 新的merge方式: rebase

通过开始的一般流程发现,每一次merge的时候,都会多出一条新的付出消息,那让历史看起来很意外。那么,能够选择rebase到master,变基,正是重复以master为骨干,把当前的提交间接移动到master的后面。不会因为提交时间的离散导致数次commit的message被拆毁。
接纳 rebase and merge
ca88官方会员登录 40

ca88官方会员登录 41

那时候,能够见见C提交的五次音信都以新型的,没有发出交叉。而且也尚无生出多余的merge新闻。
ca88官方会员登录 42

有人会问,那么岂不是看不到PXC90的地点了。点开C的野史。能够观察message下方是有P库罗德的数码的:
ca88官方会员登录 43

对了,刚初叶的PSportage要记得close
ca88官方会员登录 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

提P智跑, 那时候,借使应用merge:
ca88官方会员登录 45

ca88官方会员登录 46

结果肯定发现,1)
d提交message被遵照时间分散插入历史了(被插入到c的野史以前),
2)多了1次 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

提PLAND, 那时候,假若利用merge:
ca88官方会员登录 47

ca88官方会员登录 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

P酷路泽, rebase and merge。 这时候看history:

ca88官方会员登录 49

安分守己前两次的做法,E和F交叉在地面提交,每回commit的大运戳也是交叉,最终合并到master的时候,历史并不曾被拆毁。而是像大家期望的平等,顺序下来。那才是大家想要的。通过看图形化界面也能来看分化:

黄铜色的线是master
ca88官方会员登录 50

那便是说,操作正是fetch-》rebase。事实上,可以二合一为:

git pull --rebase origin master

ca88官方会员登录 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

P奥迪Q3, rebase and merge。 那时候看history:

ca88官方会员登录 52

依照前几遍的做法,E和F交叉在地头提交,每一次commit的小时戳也是交叉,最后合并到master的时候,历史并不曾被拆毁。而是像大家盼望的平等,顺序下来。那才是我们想要的。通过看图形化界面也能来看不同:

浅黄的线是master
ca88官方会员登录 53

那正是说,操作就是fetch-》rebase。事实上,能够二合一为:

git pull --rebase origin master

ca88官方会员登录 54

说到底结果

在都没交给到server的时候,
历史是散落在相继开发者的地面,但commit时间有程序。
ca88官方会员登录 55

按照rebase的用法,提交前rebase二回,就足以使得二个feature的交付串联到手拉手
ca88官方会员登录 56

最终在github的commit看起来也便是顺风的多
ca88官方会员登录 57

终极结出

在都没交给到server的时候,
历史是分散在依次开发者的地头,但commit时间有先后。
ca88官方会员登录 58

按照rebase的用法,提交前rebase二次,就能够使得八个feature的提交串联到一起
ca88官方会员登录 59

最后在github的commit看起来也正是顺遂的多
ca88官方会员登录 60

旗帜

  1. 想维持树的卫生,方法便是:在git push此前,先git fetch,再git
    rebase。

git fetch origin master
git rebase origin/master
git push

或者

git pull --rebase origin master

一经您把变基命令当作是在推送前清理提交使之整洁的工具,并且只在未曾推送至共用仓库的交给上实行变基命令,就不会有事。
假诺在那1个已经被推送至共用仓库的交由上执行变基命令,并就此丢掉了部分人家的成本所依据的交付,那你就有大麻烦了,你的同事也会为此看不起你。

倘诺你或你的同事在有些景况下决定要如此做,请一定要通告每一个人举办 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尽量能回顾修改内容。

参考来源

参考来源

相关文章

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图