Git的使用

声明：参考博客

　　http://www.ruanyifeng.com/blog/2015/12/git-cheat-sheet.html

　　http://www.ruanyifeng.com/blog/2012/07/git.html

一、Git工作流程图

Workspace：工作区
Index / Stage：暂存区
Repository：仓库区（或本地仓库）
Remote：远程仓库

二、Git的安装和配置

1、安装

1、liunx
Centos为例
yum install git

如果你在基于 Debian 的发行版上，请尝试用 apt-get：
apt-get install git


2、Mac安装
在mac安装git，最简单是用brew包管理
安装homebrew，然后通过homebrew安装Git：brew install git


3、Windows安装
在Windows上使用Git，可以从Git官网直接下载安装程序，然后按默认选项安装即可。
安装完成后，在开始菜单里找到“Git”->“Git Bash”，即可使用！


4、linux上的config配置
每台计算机上只需要配置一次，程序升级时会保留配置信息。 你可以在任何时候再次通过运行命令来修改它们。
Git自带一个 git config 的工具来帮助设置控制 Git 外观和行为的配置变量。 这些变量存储在三个不同的位置：
    /etc/gitconfig 文件: 包含系统上每一个用户及他们仓库的通用配置。 如果使用带有 --system 选项的 git config 时，它会从此文件读写配置变量。
    ~/.gitconfig 或 ~/.config/git/config 文件：只针对当前用户。 可以传递 --global 选项让 Git 读写此文件。
    当前使用仓库的 Git 目录中的 config 文件（就是 .git/config）：针对该仓库。 --local 当前仓库配置


5、配置用户信息
设置你的用户名称与邮件地址(这个很重要)
每一个 Git 的提交都会使用这些信息，并且它会写入到你的每一次提交中，不可更改
$ git config --global user.name "your name"
$ git config --global user.email "your email"


6、git配置相关命令
yum install git -y    安装git

git --version    查看git版本

git config --system --list    查看系统所有linux用户的通用配置,此命令检查/etc/gitconfig

git config --global --list    查看当前linux用户的配置，检查~/.gitconfig文件

git config --local --list    查看git目录中的仓库配置文件，.git/config文件

git config --global user.name "your name"    配置当前linux用户全局用户名，这台机器所有git仓库都会用这个配置

git config --global user.email "your email"    配置当前linux用户全局邮箱

git config --global color.ui true    配置git语法高亮显示

git config --list  列出git能找到的所有配置,从不同的文件中读取所有结果

git config user.name  列出git某一项配置

git help  获取git帮助

man git man  手册

git help config  获取config命令的手册

2、如何配置github

1.在电脑本地新建一个空文件夹
git init  # 初始化本地仓库

2.配置git用户名和邮箱
git config --global user.name "写你的用户名"
git config --global user.email "写你的邮箱"

3.github上配置秘匙
ssh-keygen -t rsa -b 4096 -C "你刚才配置的邮箱"  # 遇到需要输入的全按enter即可
# 生成的秘匙默认在 ~/.ssh 目录下，把公匙(pub后缀的那个文件打开即可)复制到github上
vim ~/.ssh/id_rsa.pub

4.添加仓库
首先在github上新建一个仓库，然后添加远程仓库
git remote add origin git@github.com:xxx/xxxx.git  # 远程仓库地址

5.git可正常使用了

三、Git命令

1、新建代码库

# 在当前目录新建一个Git代码库
$ git init

# 新建一个目录，将其初始化为Git代码库
$ git init [project-name]

# 下载一个项目和它的整个代码历史(克隆下来的远程仓库别名默认是:origin)
$ git clone [url]

2、配置

Git的设置文件为.gitconfig，它可以在用户主目录下（全局配置），也可以在项目目录下（项目配置）

# 显示当前的Git配置
$ git config --list

# 编辑Git配置文件
$ git config -e [--global]

# 设置提交代码时的用户信息
$ git config [--global] user.name "[name]"
$ git config [--global] user.email "[email address]"

3、增加/删除文件

# 添加指定文件到暂存区
$ git add [file1] [file2] ...

# 添加指定目录到暂存区，包括子目录
$ git add [dir]

# 添加当前目录的所有文件到暂存区
$ git add .

# 添加每个变化前，都会要求确认
# 对于同一个文件的多处变化，可以实现分次提交
$ git add -p

# 删除工作区文件，并且将这次删除放入暂存区
$ git rm [file1] [file2] ...

# 停止追踪指定文件，但该文件会保留在工作区
$ git rm --cached [file]

# 改名文件，并且将这个改名放入暂存区
$ git mv [file-original] [file-renamed]

4、代码提交

# 提交暂存区到仓库区
$ git commit -m [message]

# 提交暂存区的指定文件到仓库区
$ git commit [file1] [file2] ... -m [message]

# 提交工作区自上次commit之后的变化，直接到仓库区
$ git commit -a

# 提交时显示所有diff信息
$ git commit -v

# 使用一次新的commit，替代上一次提交
# 如果代码没有任何新变化，则用来改写上一次commit的提交信息
$ git commit --amend -m [message]

# 重做上一次commit，并包括指定文件的新变化
$ git commit --amend [file1] [file2] ...

5、分支

# 列出所有本地分支
$ git branch

# 列出所有远程分支
$ git branch -r

# 列出所有本地分支和远程分支
$ git branch -a

# 新建一个分支，但依然停留在当前分支
$ git branch [branch-name]

# 新建一个分支，并切换到该分支
$ git checkout -b [branch]

# 以某个远程分支为基准，创建新的分支
$ git checkout -b [branch] [master/develop]

# 新建一个分支，指向指定commit
$ git branch [branch] [commit]

# 新建一个分支，与指定的远程分支建立追踪关系
$ git branch --track [branch] [remote-branch]

# 切换到指定分支，并更新工作区
$ git checkout [branch-name]

# 切换到上一个分支
$ git checkout -

# 建立追踪关系，在现有分支与指定的远程分支之间
$ git branch --set-upstream [branch] [remote-branch]

# 合并指定分支到当前分支
$ git merge [branch]

# 选择一个commit，合并进当前分支
$ git cherry-pick [commit]

# 删除分支
$ git branch -d [branch-name]

# 删除远程分支
$ git push origin --delete [branch-name]
$ git branch -dr [remote/branch]

6、标签

# 列出所有tag
$ git tag

# 列出所有v1.xx的tag
$ git tag -l "v1.*"

# 新建一个tag在当前commit
$ git tag [tagName]

# 新建一个tag在指定commit
$ git tag [tagName] [commit]

# 给tag添加备注
$ git tag -a [tagName] -m "备注信息"

# 查看tag信息
$ git show [tagName]

# 提交指定tag
$ git push [remote] [tagName]

# 提交所有tag
$ git push [remote] --tags

# 删除本地tag
$ git tag -d [tagName]

# 删除远程tag
$ git push origin :refs/tags/[tagName]
$ git push origin --delete [tagName]

# 新建一个分支，指向某个tag
$ git checkout -b [branch] [tagName]

7、查看信息

# 显示有变更的文件
$ git status

# 显示当前分支的版本历史
$ git log

# 显示commit历史，以及每次commit发生变更的文件
$ git log --stat

# 搜索提交历史，根据关键词
$ git log -S [keyword]

# 显示某个commit之后的所有变动，每个commit占据一行
$ git log [tag] HEAD --pretty=format:%s

# 显示某个commit之后的所有变动，其"提交说明"必须符合搜索条件
$ git log [tag] HEAD --grep feature

# 显示某个文件的版本历史，包括文件改名
$ git log --follow [file]
$ git whatchanged [file]

# 显示指定文件相关的每一次diff
$ git log -p [file]

# 显示过去5次提交
$ git log -5 --pretty --oneline

# 显示所有提交过的用户，按提交次数排序
$ git shortlog -sn

# 显示指定文件是什么人在什么时间修改过
$ git blame [file]

# 显示暂存区和工作区的差异
$ git diff

# 显示暂存区和上一个commit的差异
$ git diff --cached [file]

# 显示工作区与当前分支最新commit之间的差异
$ git diff HEAD

# 显示两次提交之间的差异
$ git diff [first-branch]...[second-branch]

# 显示今天你写了多少行代码
$ git diff --shortstat "@{0 day ago}"

# 显示某次提交的元数据和内容变化
$ git show [commit]

# 显示某次提交发生变化的文件
$ git show --name-only [commit]

# 显示某次提交时，某个文件的内容
$ git show [commit]:[filename]

# 显示当前分支的最近几次提交
$ git reflog

8、远程同步

# 下载远程仓库的所有变动
$ git fetch [remote]

# 显示所有远程仓库
$ git remote -v

# 显示某个远程仓库的信息
$ git remote show [remote]

# 增加一个新的远程仓库，并命名
$ git remote add [shortname] [url]

# 取回远程仓库的变化，并与本地分支合并
$ git pull [remote] [branch]

# 上传本地指定分支到远程仓库
$ git push [remote] [branch]

# 强行推送当前分支到远程仓库，即使有冲突
$ git push [remote] --force

# 推送所有分支到远程仓库
$ git push [remote] --all

9、撤销

1.git reset HEAD -- <file>
将<file>从缓存区清除,回到工作区

2.git checkout -- <file>
将工作区的内容清除，先从缓存区中拉取版本还原，如果没有再到版本库中拉取还原

# 这两步就相当于：git reset --hard commit_id

3.删除新增的文件
想批量删除branch中新加的文件，git reset --hard是不行的，
也就是说上面两步是清除了新改动但还没有commit的内容，下面这一步是清除新增但还没commit的文件：
git clean -df -- .  # 删除所有新增的文件和目录
git clean -df a.txt  # 删除a.txt文件

参数：
    d: 删除目录
    f: 删除文件

4.清理所有
# 三个命令一起使用，可以将项目所有的改动清理掉
git reset HEAD -- .
git checkout -- .
git clean -df -- .

10、其他

# 生成一个可供发布的压缩包
$ git archive

四、Git的应用

1、本地连接远程仓库

连接远程仓库的方式：1.https  2.ssh

# 为什么要配置公钥和私钥：
Git使用https协议，每次pull, push都要输入密码，相当的烦。
使用git协议，然后使用ssh密钥。这样可以省去每次都输密码。
公钥我们一般是给服务器的,他们到时候在权限中加入我给的公钥,然后当我从远地仓库中下载项目的时候,我在git clone xxx的时候，那个服务器我通过他的绑定的公钥来匹配我的私钥，这个时候,如果匹配,则就可以正常下载,如果不匹配,则失败.
大多数 Git 服务器都会选择使用 SSH 公钥来进行授权。系统中的每个用户都必须提供一个公钥用于授权，没有的话就要生成一个。


# SSH公私匙的配置
1.在本地用户目录下生成公钥私钥
    ssh-keygen -t rsa -C "your_email@example.com"
2.结果会在C:UsersAdministrator.ssh生成两个.ssh文件，存放你的公钥私钥
3.把公钥放入GitHub

# 命令
1.添加远程仓库
git remote add [shortname] [ssh地址] 

2.查看连接的远程仓库的别名
git remote

3.推送代码到远程仓库
git push [shortname] [branch]

4.克隆仓库
git clone 仓库地址  --> 当你克隆了别人的仓库后，默认给仓库命名为origin

5.再次把代码推送到远程仓库
git push origin master  # 把master分支推送到远程仓库

6.从远程仓库拉代码到本地
git pull origin master
    
# 注意
如果没有配置SSH key就只能clone代码不能push上去(只读)，也就是说你的SSH key对应你github的仓库

GitHub允许添加多个Key。加入有多台电脑，你一会儿在公司提交，一会儿在家里提交，
只要把每台电脑的Key都添加到GitHub，就可以在每台电脑上往GitHub推送了。

2、上传分支代码到远程仓库

1、建立本地仓库
在你的工作目录下输入命令：git init  # 建立本地仓库


2、将代码提交到本地仓库
git add . 或者指定提交某个文件 git add [file]
git commit -m "test commit"  或指定提交某个文件 git commit [file] -m "提交信息"


3、在本地仓库中连接上一个远程仓库并给远程仓库起一个别名
git remote add origin git@XX.XX.XX.git  # 给远程仓库起别名，可以是任意的，但一般用origin
或者
git clone git@XX.XX.XX.git  # 默认也会给远程仓库起了个别名，也是origin


4、把本地的代码提交的远程仓库上
1）首先要建立本地的分支，并切换到该分支上（本地建立完分支，默认是在master分支上）
git branch my_branch  # 创建本地分支
git checkout my_branch  # 切换到这个本地分支
或者直接一条命令
git checkout -b my_branch  # 创建本地分支并切换到此分支
或者
git checkout -b my_branch origin/develop  # 以远程仓库的develop分支为基准，创建本地分支(即my_branch的代码跟develop分支的一样的)


2）把代码push到远程仓库
命令：git push <远程仓库名> <本地分支名>:<远程分支名>
应用：
1, git push origin my_branch  # origin是刚才我们为远程仓库起的别名,使用本地的对应分支来更新对应的远程分支
命令中的本地分支是指将要被推送到远端的分支，而远程分支是指推送的目标分支，即将本地分支合并到远程分支。 
如果省略远程分支名，则表示将本地分支推送与之存在”追踪关系”的远程分支(通常两者同名)，如果该远程分支不存在，则会被新建。
这里的含义是将本地my_branch这个分支提交到远程仓库上面。如果远程仓库没有这个分支，那么也会新建一个该分支。


2,另一种方法，可以指定提交到远程仓库的某个分支上。如下，是将my_branch分支提交到远程仓库的master上面
git push origin my_branch:master


5、从远程仓库拉取代码到本地分支
1.git pull <远程仓库名> <远程分支名>:<本地分支名>
git pull origin my_branch  # 将远程指定分支(my_branch) 拉取到本地当前分支上
git pull origin my_branch:local_branch  # 将远程指定分支(my_branch) 拉取到本地local_branch分支上

2.fetch
2-1.
git fetch origin master 或者 git fetch --all # 从远程的origin仓库的master分支下载到本地当前的分支
git merge origin/master # 把远程下载下来的代码合并到本地仓库

2-2.
git fetch origin master:temp  # 从远程的origin仓库的master分支下载到本地并新建一个分支temp（但不会切换到temp分支）
git merge temp  # 合并temp分支到本地当前分支


6、删除分支
1.删除本地分支: git branch -D my_branch  # 删除本地my_branch分支

2.删除远程分支
2-1.如果省略本地分支名，则表示删除指定的远程分支，因为这等同于推送一个空的本地分支到远程分支，这条命令是删除远程my_branch分支。
git push origin :my_branch

2-2.
git push origin --delete my_branch

3、从远程仓库更新代码到本地

fetch更新本地仓库几种方式：

# 方法一
$ git fetch origin master 或者 git fetch --all # 从远程的origin仓库的master分支下载到本地当前的分支

$ git merge origin/master # 把远程下载下来的代码合并到本地仓库

# 方法二
$ git fetch origin master:temp  # 从远程的origin仓库的master分支下载到本地并新建一个分支temp（但不会切换到temp分支）

$ git diff temp  # 比较本地当前分支和temp分支的不同

$ git merge temp  # 合并temp分支到本地当前分支

$ git branch -d temp  # 删除temp

# 方法三
$ git pull origin feature  # 拉取远程仓库origin下的feature分支(需要手动解决冲突)

4、解决本地代码还没push上去，但是想从远程拉取最新代码

"""
git stash会把所有未提交的修改（包括暂存的和非暂存的）都保存起来，用于后续恢复当前工作目录。

储藏(stash)可以获取你工作目录的中间状态——也就是你修改过的被追踪的文件和暂存的变更——并将它保存到一个未完结变更的堆栈中，随时可以重新应用。
"""
# 操作命令
　　1、git stash 将本地代码stash到仓库中。可以使用git stash save ***定义自己的标记，方便以后查询
　　2、git pull 将远程代码拉取到本地。
    3、git stash list查看本地仓库中都存储了几个stash版本。
　　4、git stash pop 将仓库中的代码合到本地最新代码中。
　　5、git stash pop默认将最近一次stash操作合并到本地代码中，也可以通过git stash pop stash@{Number}指定将某次stash的内容合并到本地代码中。
　　6、git stash pop命令在合并代码的同时，会把仓库中对应的内容弹出。如果只想查看，而不想弹出内容，可以使用git stash apply命令进行操作。
　　7、git stash -h 查看git stash帮助
　　8、git stash show 显示stash合并到本地代码后，哪些文件会修改，以及修改的概述
　　9、git stash show -p stash@{0} 显示修改的详细内容
    10、如果想要删除stash保存的内容：
        git stash clear  # 注意这是清空你所有的内容
        git stash drop stash@{0}  # 这是删除第一个队列

5、分支管理常用命令

多分支管理常用命令：
git checkout -b xxx(新分支名) xxx(源分支名，不指定的默认为当前分支)，-B表示，如果新分支名存在，则删除原来的分支再新建

git pull origin xxx(分支名)，最好不要直接git pull，要加上仓库和分支名，否则，容易导致pull的分支不是自己想要的

git merge origin/xxx，在执行merge前，最好先git fetch --all，把远端的仓库代码同步到本地的origin

git rebase -i xxx（节点），合并节点只能在最后提merge的时候用，开发过程中不要用。并且，如果当前分支有一个merge节点，rebase不能包括这个merge节点

git cherry-pick xxx(节点)，最好不用

6、git pull --rebase

1.git pull和git pull --rebase的区别
git pull相当于：git fetch + git merge FETCH_HEAD
git pull --rebase相当于：git fetch + git rebase FETCH_HEAD


2.merge 和 rebase的区别
现在我们有这样的两个分支,test和master，提交如下
       D---E mytest
      /
 A---B---C---F--- master


2-1.在本地master分支执行合并命令
git pull origin mytest

提交记录结果如下：
A---B---'D'---C---'E'---F---'G'---   会生成一个新的提交记录信息 G
这样的话，就会对提交记录有污染


2-2.在本地master分支执行合并命令
git pull --rebase origin mytest

提交记录结果如下：
A---B---'D'---C---'E'---F---   并不会生成额外的提交记录信息


3.小结
merge操作会生成一个新的节点，之前的提交分开显示。
而rebase操作不会生成新的节点，是将两个分支融合成一个线性的提交。


4.合并代码冲突问题
git pull 产生冲突时，相当于merge操作遇到冲突，当前merge不能继续进行下去。
解决冲突的方法：
1,手动修改冲突内容后，git add . &&  git commit -m "xxx"
2,手动修改冲突内容后，git add . &&  git merge --continue

中断合并：
如果想要中断merge操作：git merge --abort


git pull --rebase 产生冲突时，相当于rebase操作遇到冲突，会中断rebase,同时会提示去解决冲突。
解决冲突的方法：
1,手动解决冲突后,git add . &&  git rebase –-continue 继续操作，这样git会继续apply余下的补丁。
2,或者 git rebase -–skip 直接忽略冲突(一般不用这么做)

中断合并：
在任何时候，都可以用：git rebase --abort 参数来终止rebase的行动，并且分支会回到rebase开始前的状态

7、删除文件

在Git中，删除也是一个修改操作

1.当我们需要删除暂存区或分支上的文件, 同时工作区也不需要这个文件了, 可以使用
git rm file_path
git commit -m 'delete somefile'

"""
如果你是删错了，在没有commit的情况下，远程仓库里还是有那个文件的，所以可以很轻松地把误删的文件恢复过来
git checkout -- file_path

git checkout其实是用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”。
"""

2.当我们需要删除暂存区或分支上的文件, 但本地又需要使用, 只是不希望这个文件被版本控制, 可以使用
git rm --cached file_path
git commit -m 'delete remote somefile'

五、git rebase

多分支开发的时候，是不是经常就会遇到有些没必要的commit因为提交了合并请求而存在了呢，

这时候在你的commit里，看起来就不够整洁，那么该怎么办，我们可以使用rebase进行修改commit记录。

看例子吧：

比如我的commit记录如下，我需要将两条
"需要合并的commit" 合并成一条记录，
即把095759780db323f9e4ceca3a1e1dd1a8b0069d3e合并到只有
7455984ced33de3ef59a7c675993dadd6ee59b27,即删除最新(无用)的commit

### 我的commit 记录 ###

commit 095759780db323f9e4ceca3a1e1dd1a8b0069d3e
Author: ZBJ <573190041@qq.com>
Date:   Mon Nov 4 22:50:24 2019 +0800

    需要合并的commit

commit 7455984ced33de3ef59a7c675993dadd6ee59b27
Author: ZBJ <573190041@qq.com>
Date:   Mon Nov 4 22:50:09 2019 +0800

    需要合并的commit

commit ae22166712ed10091d1dce074e01ebacbf39c5fd
Author: ZBJ <573190041@qq.com>
Date:   Sat Sep 21 17:17:24 2019 +0800

    新建项目


1、在执行git rebase前，推荐把最新的commit(095759780db323f9e4ceca3a1e1dd1a8b0069d3e)保存到临时文件，万一操作失误还能reset。

2、选择rebase基点：
由于要合并的是7455984ced33de3ef59a7c675993dadd6ee59b27，
选择前一个做为rebase的基点，即：ae22166712ed10091d1dce074e01ebacbf39c5fd

执行命令：
$ git rebase -i ae22166712ed10091d1dce074e01ebacbf39c5fd
也可以使用：
$ git rebase -i 7455984ced33de3ef59a7c675993dadd6ee59b27~1，同样效果


3、修改rebase文件
执行了上面rebase命令后，默认会以 vim 进行编辑，例如我的如下：

pick 7455984 需要合并的commit
pick 0957597 需要合并的commit

# Rebase ae22166..0957597 onto ae22166 (2 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out


这里只需要关注非#注释的内容，即：
pick 7455984 需要合并的commit
pick 0957597 需要合并的commit
#注释的内容为一些帮助说明信息，不需要修改
需要注意的是，这里commit的显示顺序跟 git log 的默认显示顺序相反的


这里则使用 fixup 或 f 命令来合并，我们想要的是删除最新的commit(0957597)，即把0957597合并到前一个commit(7455984)中

修改后的内容为:
pick 7455984 需要合并的commit
f 0957597 需要合并的commit
或者
pick 7455984 需要合并的commit
fixup 0957597 需要合并的commit                                    
修改后 :wq 或者 :x 退出 vim

4、查看
此时git log 查看，会发现两条commit合并成了一条新的commit：

commit 1d2de971c6bf7f897903d7b1689dd20fe6f063d6
Author: ZBJ <573190041@qq.com>
Date:   Mon Nov 4 22:50:09 2019 +0800

    需要合并的commit

commit ae22166712ed10091d1dce074e01ebacbf39c5fd
Author: ZBJ <573190041@qq.com>
Date:   Sat Sep 21 17:17:24 2019 +0800

    新建项目


5、push推送新分支
由于rebase操作会修改版本树，如果合并的几个commit仅存在于本地，则直接推送即可
$ git push

如果合并的几个commit，已经推送到远端了，则需要把本地的版本树覆盖掉远端，在push时使用--force或-f参数来强推
$ git push -f

6、如果需要修改commit的提交记录内容
有两种场景：
要修改的 commit 是最新的一次提交
要修改的 commit 不是最新的一次提交

6-1、要修改的 commit 是最新的一次提交
使用 commit 命令的 --amend 参数可以完成快速修改：
git commit --amend

会出现如下内容，此时直接修改那条commit记录的内容即可：

需要合并的commit

# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# Date:      Mon Nov 4 22:50:09 2019 +0800
#
# On branch DRF
# Changes to be committed:
#       modified:   .idea/workspace.xml

6-2、要修改的 commit 不是最新的一次提交
这种情况需要使用 git rebase -i 来修改，
首先找到要修改的记录：ae22166712ed10091d1dce074e01ebacbf39c5fd
$ git rebase -i ae22166712ed10091d1dce074e01ebacbf39c5fd~1

pick ae22166 新建项目
pick 65c1138 需要合并的commit记录

# Rebase 50a09c3..65c1138 onto 50a09c3 (2 commands)
#
# Commands:
# p, pick <commit> = use commit
# r, reword <commit> = use commit, but edit the commit message
# e, edit <commit> = use commit, but stop for amending
# s, squash <commit> = use commit, but meld into previous commit
# f, fixup <commit> = like "squash", but discard this commit's log message
# x, exec <command> = run command (the rest of the line) using shell
# b, break = stop here (continue rebase later with 'git rebase --continue')
# d, drop <commit> = remove commit
# l, label <label> = label current HEAD with a name
# t, reset <label> = reset HEAD to a label
# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
# .       create a merge commit using the original merge commit's
# .       message (or the oneline, if no original merge commit was
# .       specified). Use -c <commit> to reword the commit message.
#
# These lines can be re-ordered; they are executed from top to bottom.
#
# If you remove a line here THAT COMMIT WILL BE LOST.
#
# However, if you remove everything, the rebase will be aborted.
#
# Note that empty commits are commented out


# 步骤
1.找到需要修改的记录(pick ae22166 新建项目)，把 pick 改成 r 或者 reword，保存退出
2.接着会自动进入该条commit的编辑界面，此时可以直接修改commit内容，然后保存退出即可
3.看到 Successfully rebased and updated 就表示修改成功了，再看 git log

六、清理项目

1.git reset HEAD -- <file>
将<file>从缓存区清除,回到工作区

2.git checkout -- <file>
将工作区的内容清除，先从缓存区中拉取版本还原，如果没有再到版本库中拉取还原

# 这两步就相当于：git reset --hard commit_id

3.删除新增的文件
想批量删除branch中新加的文件，git reset --hard是不行的，
也就是说上面两步是清除了新改动但还没有commit的内容，下面这一步是清除新增但还没commit的文件：
git clean -df -- .  # 删除所有新增的文件和目录
git clean -df a.txt  # 删除a.txt文件

参数：
    d: 删除目录
    f: 删除文件

4.清理所有
# 三个命令一起使用，可以将项目所有的改动清理掉
git reset HEAD -- .
git checkout -- .
git clean -df -- .

七、Git分支管理策略

1、主分支Master

首先，代码库应该有一个、且仅有一个主分支。所有提供给用户使用的正式版本，都在这个主分支上发布。

 

Git主分支的名字，默认叫做Master。它是自动建立的，版本库初始化以后，默认就是在主分支在进行开发。

2、开发分支Develop

主分支只用来分布重大版本，日常开发应该在另一条分支上完成。我们把开发用的分支，叫做Develop。

这个分支可以用来生成代码的最新隔夜版本（nightly）。如果想正式对外发布，就在Master分支上，对Develop分支进行"合并"（merge）。

1.Git创建Develop分支的命令：
git checkout -b develop master

2.将Develop分支发布到Master分支的命令：
# 切换到Master分支
git checkout master

# 对Develop分支进行合并
git merge --no-ff develop

上一条命令的--no-ff参数是什么意思。默认情况下，Git执行"快进式合并"（fast-farward merge），会直接将Master分支指向Develop分支。

使用--no-ff参数后，会执行正常合并，在Master分支上生成一个新节点。为了保证版本演进的清晰，我们希望采用这种做法。

3、临时性分支

前面讲到版本库的两条主要分支：Master和Develop。前者用于正式发布，后者用于日常开发。其实，常设分支只需要这两条就够了，不需要其他了。

但是，除了常设分支以外，还有一些临时性分支，用于应对一些特定目的的版本开发。临时性分支主要有三种：

• 　　* 功能（feature）分支
• 　　* 预发布（release）分支
• 　　* 修补bug（fixbug）分支

 这三种分支都属于临时性需要，使用完以后，应该删除，使得代码库的常设分支始终只有Master和Develop。

4、 功能分支

第一种是功能分支，它是为了开发某种特定功能，从Develop分支上面分出来的。开发完成后，要再并入Develop。

 

功能分支的名字，可以采用feature-*的形式命名。

创建一个功能分支：
　　git checkout -b feature-x develop

开发完成后，将功能分支合并到develop分支：
　　git checkout develop
　　git merge --no-ff feature-x

删除feature分支：
　　git branch -d feature-x

5、预发布分支

第二种是预发布分支，它是指发布正式版本之前（即合并到Master分支之前），我们可能需要有一个预发布的版本进行测试。

预发布分支是从Develop分支上面分出来的，预发布结束以后，必须合并进Develop和Master分支。它的命名，可以采用release-*的形式。

创建一个预发布分支：
　　git checkout -b release-1.2 develop

确认没有问题后，合并到master分支：
　　git checkout master
　　git merge --no-ff release-1.2

对合并生成的新节点，做一个标签
　　git tag -a 1.2

再合并到develop分支：
　　git checkout develop
　　git merge --no-ff release-1.2

最后，删除预发布分支：
　　git branch -d release-1.2

6、修补bug分支

最后一种是修补bug分支。软件正式发布以后，难免会出现bug。这时就需要创建一个分支，进行bug修补。

修补bug分支是从Master分支上面分出来的。修补结束以后，再合并进Master和Develop分支。它的命名，可以采用fixbug-*的形式。

 

创建一个修补bug分支：
　　git checkout -b fixbug-0.1 master

修补结束后，合并到master分支：
　　git checkout master
　　git merge --no-ff fixbug-0.1
　　git tag -a 0.1.1

再合并到develop分支：
　　git checkout develop
　　git merge --no-ff fixbug-0.1

最后，删除"修补bug分支"：
　　git branch -d fixbug-0.1