Git-使用和管理

拉丁卡特

已于 2022-04-19 14:58:30 修改

阅读量237

点赞数

文章标签： git

于 2020-02-06 12:54:11 首次发布

本文链接：https://blog.csdn.net/u013217730/article/details/104194826

版权

文章目录

Git使用和管理

Git使用和管理

一、Git分支管理

Git分支管理工具SourceTree

二、Git命令

1、diff

git diff 当工作区有改动，临时区为空，diff的对比是“工作区与最后一次commit提交的仓库的共同文件（只比较之前已经存在的文件不比较最新新增的文件）”；当工作区有改动，临时区不为空，diff对比的是“工作区共同文件（不包含缓存区）”。
git diff --cached 或 git diff --staged：显示暂存区(已add但未commit文件)和最后一次commit(HEAD)之间的所有不相同文件的增删改(git diff --cached和git diff –staged相同作用) （只比较已经add的文件和最后一次提交的文件）
git diff HEAD：显示工作目录(已track但未add文件)和暂存区(已add但未commit文件)与最后一次commit之间的的所有不相同文件的增删改。(和git diff 不同的是git diff HEAD 可以比较缓存区文件)
git diff HEAD~X或git diff HEAD^^^{…(后面有X个}符号，X为正整数):可以查看最近一次提交的版本与往过去时间线前数X个的版本之间的所有同(3)中定义文件之间的增删改。（如果git diff HEAD~1表示当前最后提交和上一步提交的差异，并且包含当前缓存区和工作区内容与之前版本的比较）
git diff <分支名1> <分支名2> ：比较两个分支上最后 commit 的内容的差别
git diff branch1 branch2 --stat 显示出所有有差异的文件(不详细,没有对比内容)
-
git diff branch1 branch2 c:\aa.java 显示指定文件的详细差异(对比内容)
git diff head~1 head 比较一般顺序指后面commit的内容比前一个增加了什么或则删除了什么

参考：https://blog.csdn.net/wq6ylg08/article/details/88798254

2、git log

注：https://blog.csdn.net/zhuge1127/article/details/82494783

git log --oneline --graph 当前分支
git log --oneline --graph --all

*表示一个commit， 注意不要管*在哪一条主线上
|表示分支前进
/表示分叉
\表示合入

三、Git使用

Git 工作区、暂存区和版本库

工作区：就是你在电脑里能看到的目录。
暂存区：英文叫stage, 或index。一般存放在 “.git目录下” 下的index文件（.git/index）中，所以我们把暂存区有时也叫作索引（index）。
版本库：工作区有一个隐藏目录.git，这个不算工作区，而是Git的版本库。

在这里插入图片描述

Git 标签Tag

Git Tag标签对应的是历史提交中的一个Commit，跟分支类似，但是分支可以合并移动，Tag不行。

Tag主要是为了标记一次发版的快照
创建标签命令：

//创建标签
[root@Git git]# git tag v1.0
//查看标签
[root@Git git]# git tag
v1.0
[root@Git git]# git tag v1.1
[root@Git git]# git tag
v1.0
v1.1
//删除标签
[root@Git git]# git tag -d v1.1
Deleted tag ‘v1.1’ (was 91388f0)
[root@Git git]# git tag
v1.0
//查看此版本修改的内容
[root@Git git]# git show v1.0
commit 91388f0883903ac9014e006611944f6688170ef4
Author: "syaving" <"819044347@qq.com">
Date: Fri Dec 16 02:32:05 2016 +0800
commit dir
diff –git a/readme b/readme
index 7a3d711..bfecb47 100644
— a/readme
+++ b/readme
@@ -1,2 +1,3 @@
text
hello git
+use commit
[root@Git git]# git log –oneline
91388f0 commit dir
e435fe8 add readme
2525062 add readme

git标准工作使用

#创建新分支
git branch develop 
git checkout develop 

这两步可以合成一步
git checkout -b develop

#创建并关联远程分支
git push --set-upstream origin develop

这个命令只能创建远程分支并没有关联本地分支
git push origin develop

#删除本地分支
git branch -d develop

强制删除
git branch -D develop

#删除远程分支
git push origin --delete develop

#从远程分支上拉取代码
获取远程分支内容
git fetch orgin develop

查看本地分支和远程分支上的提交内容差异日志（所有提交的差异比较）
git log -p  develop origin/develop 或则 git log -p FETCH_HEAD

合并到本地分支，如果有冲突执行merge命令后会提示结果和冲突文件，然后手动处理冲突文件然后git add .  git commit  git push
git merge FETCH_HEAD  或则 git merge origin/develop 

上面的操作等同于（如果是和当前本地分支合并，冒号后面的分支可以省略），其中直接执行git pull 也会提示冲突文件 其实效果跟git fetch+git merge 差不多
git pull origin develop : develop   //pull 等同于 fetch和merge

git fetch原理
我们本地的git文件夹里面对应也存储了git本地仓库master分支的commit ID 和 跟踪的远程分支orign/master的commit ID（可以有多个远程仓库）。那什么是跟踪的远程分支呢，打开git文件夹可以看到如下文件：
.git/refs/head/[本地分支]
.git/refs/remotes/[正在跟踪的分支]
其中head就是本地分支，remotes是跟踪的远程分支，这个类型的分支在某种类型上是十分相似的，他们都是表示提交的SHA1校验和（就是commitID）。
使用git fetch更新代码，本地的库中master的commitID不变，还是等于1。但是与git上面关联的那个orign/master的commit ID变成了2。这时候我们本地相当于存储了两个代码的版本号，我们还要通过merge去合并这两个不同的代码版本，如果这两个版本都修改了同一处的代码，这时候merge就会出现冲突，然后我们解决冲突之后就生成了一个新的代码版本。
(https://blog.csdn.net/weixin_41975655/article/details/82887273)


拉取并合并代码  
git pull --rebase

git pull = git fetch + git merge FETCH_HEAD 
git pull --rebase =  git fetch + git rebase FETCH_HEAD 
merge操作会生成一个新的节点，之前的提交分开显示。
而rebase操作不会生成新的节点，是将两个分支融合成一个线性的提交。 
想要更好的提交树，使用rebase操作会更好一点。
这样可以线性的看到每一次提交，并且没有增加提交节点。
其他解决冲突过程类似
(https://www.jianshu.com/p/dc367c8dca8e)

##合并其他分支
git merge feature  //把本地feature分支合并到本地develop

##创建标签tag，标记发布版本
git tag -a v1.0.0-release -m "1.0.0-release"

##代码推到远程仓库
git push origin develop

##代码标签tag推到远程仓库
git push origin --tags


##根据tag创建修复fix-bug01分支
git checkout -b fix-bug01 v1.0.0-release

##git push 代码前先git pull如果有冲突再git merge
git pull
git merge
git push

四、Git实战

# git命令帮助查看
git --help  //查看git 包含的命令

git commit --help //查看每个命令的具体操作

##配置User信息(在提交代码时会有标识，并且在出现版本版本变更时可以发邮件到对应邮箱)
git config --global user.name your_name   //不用带引号
git config --global user.email your_email
新增或则修改config配置
git config --local  //只对某个仓库有效
git config --global  //对当前用户所有仓库都有效
git config --system //对当前登录用户有效 （这个基本上不用）

查看当前配置
git config --list
git config --list --global  //当前仓库中没有设置local默认使用global
git config --list --local  //local 只能在当前仓库目录下使用
git config --list --system
注：自己下载的源码尽量设置local config不然默认使用global可能是设置公司的git账号密码。

##创建GIT本地仓库 并关联到GitHub远程仓库
把已有的项目纳入git管理
git init  //进入项目所在的文件夹

新建项目使用git管理并关联到远程仓库
git init your_project  //会在当前路径下创建和项目名称同名的文件夹

git add your_file_name

git commit -m "first commit"   //commit信息如果在windows系统中不能使用单引号不然会报错，只能在linux系统中使用单引号，这是系统命令行语法的问题

git remote add origin git_url   //git_url 是已创建的远程仓库地址

git pull //拉取远程仓库内容分支到本地

git branch --set-upstream-to=origin/remote_branch  your_branch  //把已拉到本地的远程分支 和 本地分支绑定关联

注：不能没绑定直接 git push --set-upstream origin remote_branch  如果远程仓库有对应的分支会报错forward不一致

git pull --allow-unrelated-histories  //把本地分支和远程分支合并，之前只是做了关联并未合并
注：如果只是git pull 不能合并成功，因为两个分支是完全独立的

git push //推送到远程仓库

-u 可以指定不同的远程主机 origin 或则其他
git push -u origin master


##git提交
git add your_file_name

git add .   //将未被git管理的文件的新增和git管理的文件的修改或则删除加入到暂存区
git add -u //只暂存已经被git管理的文件的修改或则删除 （使用-u可以避免把工作区没有准备好的文件加入进去）

git add 可以把新增文件加入到git版本管理中，但是如果你想移除可以使用 git reset commit_id（最新一次提交的commit_id）

git reset commit_id //commit_it 为最新一次，可以还原add内容

git commit -m "your_comment"
git commit -am 'you_comment'   //把工作区的内容直接提交到版本历史中

注：工作目录-add->暂存区-commit->版本历史   其中暂存区已经可以被git管理了，只是还没有提交到历史版本（在某一次修改代码后可以先add到暂存区，然后再修改代码如果当前修改的代码不理想可以还原到暂存区）

良好的git工作模式是先在工作目录修改内容然后提交到暂存区，最后再统一commit到版本历史。

##git重命名文件

比较繁琐的方式
git add your_new_file
git rm your_old_file

比较简便的方式
git mv your_old_file your_new_file


##git查看版本历史
git log
//查看提交内容中的一行信息
git log --oneline
//查看前4次提交的内容
git log -n4 --oneline 
//查看前两次的提交包括涉及的文件修改
git log -2 --stat
git log commit_id --stat

//通过show可以查看当前提交commit_id的相关文件和diff文件差异
git show commit_id

git show commit_id --stat //只显示当前commit_id对应的文件，不显示内容差异

查看所有分支
git log --all 
按图形化显示分支提交历史
git log --graph
按图形化显示所有分支的一行提交内容的前4次提交历史
git log --all --graph --oneline -n4


##查看命令帮助 
git help your_command  //会跳出一个网页来查看该命令和参数的使用方式
git help --web your_command   //也可以指定使用web网页形式查看帮助文档，默认也是以网页形式查看

###git图形界面查看所有分支的版本历史提交
gitk  //输入gitk会弹出一个gitk的图形界面可以查看所有的历史提交内容
gitk --all

提交历史内容中会有一个author和committer分别表示文件创建人或则修改人和文件提交人，通常会在你从别的分支拿过来的文件然后提交上去会出现两个不一致的情况。

##比较差异
比较两次提交的commit的差异
git diff commit_id commit_id_other

HEAD可以表示一次提交的commit，HEAD^是表示当前HEAD的父提交commit
git diff HEAD HEAD^  //如果是更上一级父提交可以使用^^或则更多
git diff HEAD HEAD~1 // ~1和^效果一样 如果表示更上一级的父提交可以使用~2或则更多


##修改git commit message
git commit --amend  //然后进入编辑器（和vi类似）可以修改最近一次提交的message信息 以后修改commit message 信息不用reset回滚了

撤销commit --amend
撤销 git commit --amend

_Lyux
1
2017.12.21 13:18:54
字数 518
阅读 25,483
想必大家都知道 git commit --amend 这条实用命令, 其可以用来修改最后一条提交的 commit message, 也可以追加新的修改.
但有时候不小心 amend 了错误的内容, 如何回退呢?
普通青年一般会用 git reset 撤销到上一个提交, 再重新 git commit 一次, 这固然是可以的. 但如果工作区此时已经改的面目全非, 这时如果执行 git reset, 就很难分的清哪些内容属于被撤销的提交了. 嗯, 这位同学说这种情况可以用 git stash 来处理, 是可以解决问题的.
但是, 身为文艺青年, 怎么能用这么不优(zhuang)雅(bi)的方法呢.

先上结论:
如果只 amend 了一次, 那么直接用 git reset HEAD@{1} 就可以撤销这次 amend. 如果 amend 多次, 就参考 git reflog 进行撤销.

下面以实例介绍如何就地撤销 git commit --amend.

制造事故现场
首先制造事故现场. 追加空行到项目中的 index.html 文件下:

$ echo "" >> index.html 
$ git add .
$ git commit -m "add blank line to index.html"
然后再加一行到 index.html, 并 amend 一下:

$ echo "this line would break the code" >> index.html 
$ git add .
$ git commit --amend
现场已经出现, 我们要撤销 amend 的那个提交.

撤销 amend
首先使用 git reflog 命令查看操作记录:

$ git reflog
c1c1b21 HEAD@{0}: commit (amend): add blank line to index.html
9ff821d HEAD@{1}: commit: add blank line to index.html
b078331 HEAD@{2}: commit: no more commit!
b86e902 HEAD@{3}: commit: so many commit
77e6ce9 HEAD@{4}: commit: this is another commit
ccde039 HEAD@{5}: commit: this is a commit
a49dcf4 HEAD@{6}: clone: from ssh://liux@xxx.xx.xx.xxx:29418/git_test.git
看到 amend 操作之前的最后一个操作就是 HEAD@{1}.
现在可以用 git reset 将当前分支的 HEAD 指向 HEAD@{1}, 即可达到撤销 amend 的目的:

$ git reset --soft HEAD@{1}
$ git status
On branch master
Your branch is ahead of 'origin/master' by 5 commits.
  (use "git push" to publish your local commits)
Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)

    modified:   index.html
随即使用 git status 查看状态, 发现 amend 的内容已经被撤销 (到工作区) 了.
如果想撤销到暂存区, 就用 git reset --soft HEAD@{1} .
如果想干掉这个修改, 就用 git reset --hard HEAD@{1} .
这和 git reset 操作 commit 的情形是一样的.

如果一个 commit 被 amend 了多次, 也可以用这种方法撤销到任意一次 amend 处:

$ git reflog
937fd53 HEAD@{0}: commit (amend): add blank line to index.html
7589755 HEAD@{1}: commit (amend): add blank line to index.html
f7ade82 HEAD@{2}: commit (amend): add blank line to index.html
c1c1b21 HEAD@{3}: commit (amend): add blank line to index.html
9ff821d HEAD@{4}: commit: add blank line to index.html
$ git reset --soft HEAD@{2}
可以看出, 不止是 amend 操作, 其他操作也可以用这种方法进行撤销.




如果改变之前的提交message需要使用rebase变基命令，并且会进入交互式编辑器，上面有提示参数使用方式，如果是修改message信息选择reword命令然后修改后面的commit信息即可，pick就是选择保留的commit信息，然后修改你想要的结果就行了
git rebase -i commit_id  //这个变基操作会把后面的commit_id修改掉重新生成也就是HEAD也会重新指向新的commit_id，其中有用到之前的分离头指针的操作



###  消除频繁提交记录 amend

git add .

git status

git commit --amend

git branch --vv  查看当前分支是否关联远程分支

git push origin :feature_xxx  删除对应的远程分支，前提是这个分支只有自己开发功能在用

git push -u origin feature_xxx  重新推送到远程并创建对应的远程分支

git log -2 查看日志记录是否被覆盖



#### rebase 修改commit comment过程
查看提交记录commit_id
git log --oneline -10
选择最久远的需要修改的提交的前一个提交上复制commit_id
git rebase -i commit_id
进入vi编辑界面，输入i，然后在需要修改的commit message前将pick修改为reword，然后点Esc，按组合键shift+:，然后输入wq。
进入修改comment的vi界面，同上面步骤修改comment，然后wq保存退出即可。
然后push已修改的comment，如果当前修改已经push过了需要加上--force（此操作要谨慎）
git push 或则 git push --force

#### rebase 多人开发同一分支
在多人开发同一分支的情况下，如果没有及时更新代码会造成本地分支和远程分支提交历史不一致，可能会造成分叉合并到本地分支。
对于部分强迫症不想看到分叉，就会执行rebase（有重新修改地基的意思）
git rebase 
然后push到远程
git push

或者pull代码时直接执行 --rebase
git pull --rebase
然后push就行。

#### rebase 不同分支


###git合并多个连续commit

还是使用rebase变基 然后commit_id，然后把需要合并的commit信息选择squash命令，就是合并到最上面提交的commit中，最上面的commit也是使用pick命令保留，最后一个选择点的commit还选择pick，然后使用wq!保存，最后会跳到编辑commit信息界面，然后新增合并后的commit信息即可，通常是最上面（最上面的是最老的commit）写上合并的message信息，下面需要合并的几次commit信息可以保留也可以使用注释注掉（如要合并其中四个commit，rebase命令选择第五个commit_id，然后保留最上面的commit pick，把中间三个命令使用squash合并即可）
git rebase -i commit_id   

###git把间隔的几个commit合并成一个

### git修改查看暂存区和HEAD指针位置的差异
git diff HEAD --cached   //--cached命令参数 是指比较暂存区和提交记录HEAD

git diff commit_id --cached  //指定暂存区和对应的提交历史版本比较差异
查看工作区和暂存区的差异
git diff 

查看工作区和暂存区的差异并且指定文件比较
git diff -- file1 file2

git checkout --cached filename
把暂存区的文件恢复到工作区


git reset HEAD -- filename   
撤销某个文件的暂存区，也可以跟多个文件

git reset --hard commitid
回滚到某次提交历史 hard 指同时暂存区和工作区也恢复到这个版本


git diff master develop 
git diff master develop --filename
比较两个分支或者两个分支的某个文件差异，分支其实就是该分支下的最近一次提交


git rm filename 
git删除文件并add到暂存区，这是比较正确的删除git仓库文件的方式


## git stash

把当前工作区和暂存区的内容放到stash中暂存   如果有多个暂存最新的是头部0
git stash   //stash执行暂存

git stash save "save message"  //执行暂存时加上备注信息

查看stash了那些存储
git stash list 

查看stash做了那些改动，默认查看第一个存储
git stash show 

git stash show -p stash@{num}

查看某一个存储的改动点，num是从0开始的
git stash show stash@{num} -p  //git stash show stash@{1} -p
 
还原某个存储，但不删除，默认是第一个
git stash apply
git stash apply stash@{num}  //git stash apply stash@{0} 


取出某个存储，但是取出后会删除，默认是第一个
git stash pop
git stash pop stash@{num} //git stash pop stash@{1}

丢弃stash@{num} 存储，直接删除不恢复或则还原
git stash drop stash@{num} 

把当前工作区和暂存区的内容放到stash中暂存
然后可以处理临时加塞的工作
最后处理完临时加塞的工作后使用apply或者pop来恢复stash内容
pop会取出并移出当前最新stash内容
apply只是应用不会移出就是可以重复使用

git stash 只会暂存对于已经加入git管理的文件，所以对于新文件需要git add 到git中，commit后的文件不需要git add ，因为commit文件已经已经被git 管理了，所以git 命令基本上都是需要加入到git 管理中的文件才能生效，一般只对应新文件还没git add的

常规 git stash 的一个限制是它会一下暂存所有的文件。有时，只备份某些文件更为方便，让另外一些与代码库保持一致。一个非常有用的技巧，用来备份部分文件：

add 那些你不想备份的文件（例如： git add file1.js, file2.js）
调用 git stash –keep-index。只会备份那些没有被add的文件。
调用 git reset 取消已经add的文件的备份，继续自己的工作。


git pull 出现冲突可以使用git stash 先把本地工作区和暂存区放入stash栈中，然后在git pull，再git stash apply把栈中的文件恢复到本地，这样再处理有冲突的文件内容。

### 从远程分支切取到本地
git fetch origin branch_name   //如果本地仓库已经拉倒对应的远程分支了就不用执行fetch了  或者直接执行git pull 

git checkout -b branch_name origin/branch_name   //从远程分支切到并新建本地分支，并且关联到对应的远程分支



注：origin branch_name 或则origin/branch_name 使用区别，如果是更远程仓库有关系的操作如push 或则pull 操作等使用 origin branch_name，如果是跟已经拉到本地的远程分支有关系的操作使用origin/branch_name，代表是本地仓库的操作。origin/branch_name就是代表已经拉到本地的远程分支。加个origin/和本地分支做区分。

### 删除本地分支
git branch -d branch_name //删除本地分支，需要先切换掉其他分支，然后执行删除分支的命令
git branch -D branch_name   // 强制删除本地分支，如果使用-d有可能提示你还没有把待删除分支合并到当前分支

git branch -r -d origin/branch_name // 删除远程分支 通过本地和远程分支的关联删除远程分支
#删除远程分支
git push origin --delete develop  //直接向远程仓库发送删除分支的命令





## 仓库搜索和高级搜索
搜索例子：
在readme中检索关键字
git 最好 学习 资料 in:readme
在readme中检索关键字 并且stars数量大于1000的仓库
git 最好 学习 资料 in:readme stars:>1000

根据代码内容进行搜索  代码内容搜索和仓库stars数量不能同时使用
git 最好 学习 资料 filename:file_name

blog easily start in:readme stars:>5000

### git查看远程仓库信息
git remote -v

如果输出有origin 和 upstream 一般是在github上fork自己仓库的项目clone到本地会出现的结果
origin 对应自己仓库的远程地址
upstream 对应fork的项目原来远程仓库地址
原因是git本来没有fork命令，所以clone到本地的fork项目就会出现两个远程仓库信息，默认是origin，当然也可以指定。如：git fetch origin  或则 git fetch upstream


### git Fast-forward

Fast-forward 表示远程仓库分支最新的commit提交记录作为该分支的Fast-forward，本地分支要push到远程分支，都要求本地分支已经包含Fast-forward远程最新commit提交记录，否则会push提示报错no-fast-forward。所以在每次push本地分支前一半需要pull或则fetch远程分支，把Fast-forward拉倒本地，如果有冲突合并后再push。

Fast forward能够保证不会强制覆盖别人的代码，确保了多人协同开发。尽量不要使用non Fast forward方法提交代码。

git push -f 可以强制提交并覆盖到远程分支，忽略Fast-forward，一般情况下绝对不允许这样做，这样容易导致代码丢失。


## git restore 恢复

git restore --staged file   //把暂存区的内容移除到工作区，并不会修改文件

git restore file  //这个是工作区中修改删除掉，对于还没有add到暂存区的内容会删掉

## git reset

reset回退 revert恢复

git reset HEAD <filename> （撤销某个已经add的文件暂存区）
git reset HEAD .              （撤销所有已经add的文件暂存区）

git reset --hard|soft commit_id|HEAD  <filename>   (hard 之后提交的文件不会放暂存区，soft 会放暂存区) （如果带文件名 表示回退某个文件）
git reset --mixed  commit_id|HEAD  （默认 mixed，mixed 不存保存在缓存区 但是会保存在工作目录，如add的内容reset 后需要重新add添加缓存区 )
git reset --mixed <filename> (移除某个add 的文件暂存区)

注：
git revert 会产生一次新的提交
git reset 不会产生新的提交 直接回退HEAD 指针

1）通过git reset是直接删除指定的commit

git log # 得到你需要回退一次提交的commit id
git reset --hard <commit_id>
git push origin HEAD --force # 强制提交一次，之前错误的提交就从远程仓库删除，这是针对已经提交到远程仓库的错误提交记录

2）通过git revert是用一次新的commit来回滚之前的commit

git log # 得到你需要回退一次提交的commit id
git revert <commit_id>  # 撤销指定的版本，撤销也会作为一次提交进行保存

3） git revert 和 git reset的区别
- git revert是用一次新的commit来回滚之前的commit，此次提交之前的commit都会被保留；

- git reset是回到某次提交，提交及之前的commit都会被保留，但是此commit id之后的修改都会被删除


## git 命令设置别名alias
 There is two easy way to set the alias.

1、Using Bash
2、Updating .gitconfig file

Using Bash

Open bash terminal and type git command. For instance:

$ git config --global alias.a add
$ git config --global alias.aa "add ."
$ git config --global alias.cm "commit -m"
$ git config --global alias.s status
---
---
It will eventually add those aliases on .gitconfig file.

Updating .gitconfig file

Open .gitconfig file located at 'C:\Users\username\.gitconfig' in Windows environment. Then add following lines:

[alias]  
a = add  
aa = "add ." 
cm = "commit -m"
gau = "add --update"
au = "add --update"
b = branch
---
---



## git grep file_name
git 查询仓库中的文件



## git pull和git merge

git pull 是 git fatch + git merge  

如果git merge 过程中有冲突会暂停merge，然后通过git status查看冲突文件并解决冲突后 git add ，使用git merge --continue继续merge操作。

merge本身会包含commit提交操作，生成一个merge commitid自动提交到分支中。


### git pull --rebase 和 git merge --no-ff
git pull --rebase //表示不merge 执行rebase变基操作
git merge --no-ff  //表示merge是主动创建分叉 默认是ff  fast forward

## git rebase
rebase是一个变基操作，可以减少多人协同开发同一分支时merge出现的分叉
但是rebase是一个危险的操作，如果不是很熟悉不要轻易用

rebase 和 merge 最后的代码结果都是一样的，主要区别是rebase操作分支不会出现分叉，merge会分叉并且产生一个无意义的merge commit

注：：git rebase 很危险需要实验过后才能提交，会出现变基后本地代码被干掉

## git tag

git tag //查看所有tag

git tag tag_name //创建tag

git push --tags //推送tag到远程仓库

git checkout tag_name    （git checkout 加上-b就表示切换新分支了）
但是，这时候 git 可能会提示你当前处于一个“detached HEAD" 状态。

因为 tag 相当于是一个快照，是不能更改它的代码的。

如果要在 tag 代码的基础上做修改，你需要一个分支： 

git checkout -b branch_name tag_name
这样会从 tag 创建一个分支，然后就和普通的 git 操作一样了。







##########################################################################################################################

## git branch查看分支

git branch -l   //只显示本地分支
git branch -r   //查看所有远程分支
git branch -v   //只显示本地分支和对应最新commit版本信息
git branch -vv //查看本地分支和对应的远程分支
git branch -a  //显示本地分支和远程分支
git branch -av  //显示远程分支和本地分支 以及对应的commit版本信息

git branch -l "*branch_name*"  //查找分支 并且通过*来进行通配

git branch -r -l "*name*"  //可以和其他参数配合使用

注：自己开发一个包含前后端的项目的时候可以分别创建两个分支，一个专门修改前端，一个专门修改后端，两个分支互不影响，后面需要合并可以合并到一个分支测试。

#创建新分支
git branch develop 
git checkout develop 

这两步可以合成一步 默认是基于当前分支
git checkout -b develop

创建完本地分支后创建并关联到对应的远程分支：
git push --set-upstream origin develop   //develop 要存在对应名称的本地分支 才能在远程仓库创建分支并且做关联

创建新分支并指定基于某个分支
git checkout -b develop master

可以根据版本历史commit_id来创建新分支
git checkout -b temp commit_id

注：分离头指针操作是你在切换分支时并没有切换到一个实际创建的分支上，而是与某个commit_id进行关联切出，后面如果你提交了内容并且切换到其他分支上时，你之前分离头指针增加的内容可以被Git清理掉（由于git会判断分离头指针没有和实际分支绑定）
git checkout commit_id   //这中一般用于实验性的内容
git branch your_new_branch commit_id  //可以通过这种方式进行关联具体分支进行git永久保存

#创建完新分支并关联远程分支

git push --set-upstream origin develop

这个命令只能创建远程分支并没有关联本地分支
git push origin develop
创建远程分支并且关联本地分支
git push origin develop:develop 

#删除本地分支
git branch -d develop

强制删除
git branch -D develop


#从远程分支上拉取代码
获取远程分支内容
git fetch orgin develop

查看本地分支和远程分支上的提交内容差异日志（所有提交的差异比较）
git log -p  develop origin/develop 或则 git log -p FETCH_HEAD

合并到本地分支，如果有冲突执行merge命令后会提示结果和冲突文件，然后手动处理冲突文件然后git add .  git commit  git push
git merge FETCH_HEAD  或则 git merge origin/develop 



上面的操作等同于（如果是和当前本地分支合并，冒号后面的分支可以省略，如果省略是合并到当前分支），其中直接执行git pull 也会提示冲突文件 其实效果跟git fetch+git merge 差不多
git pull origin develop : develop   //pull 等同于 fetch和merge  经过测试这样也会合并到本地当前分支

git pull orgin develop  //指定远程分支拉取并合并到本地，如果当前是feature分支相当于把远程develop 分支合并到feature，不用再切换develop分支再pull 再切回来再meger

git fetch原理
我们本地的git文件夹里面对应也存储了git本地仓库master分支的commit ID 和 跟踪的远程分支orign/master的commit ID（可以有多个远程仓库）。那什么是跟踪的远程分支呢，打开git文件夹可以看到如下文件：
.git/refs/head/[本地分支]
.git/refs/remotes/[正在跟踪的分支]
其中head就是本地分支，remotes是跟踪的远程分支，这个类型的分支在某种类型上是十分相似的，他们都是表示提交的SHA1校验和（就是commitID）。
使用git fetch更新代码，本地的库中master的commitID不变，还是等于1。但是与git上面关联的那个orign/master的commit ID变成了2。这时候我们本地相当于存储了两个代码的版本号，我们还要通过merge去合并这两个不同的代码版本，如果这两个版本都修改了同一处的代码，这时候merge就会出现冲突，然后我们解决冲突之后就生成了一个新的代码版本。
(https://blog.csdn.net/weixin_41975655/article/details/82887273)


拉取并合并代码  
git pull --rebase

git pull = git fetch + git merge FETCH_HEAD 
git pull --rebase =  git fetch + git rebase FETCH_HEAD 
merge操作会生成一个新的节点，之前的提交分开显示。
而rebase操作不会生成新的节点，是将两个分支融合成一个线性的提交。 
想要更好的提交树，使用rebase操作会更好一点。
这样可以线性的看到每一次提交，并且没有增加提交节点。
其他解决冲突过程类似
(https://www.jianshu.com/p/dc367c8dca8e)

##合并其他分支
git merge feature  //把本地feature分支合并到本地develop


##创建标签tag，标记发布版本
git tag -a v1.0.0-release -m "1.0.0-release"

##代码推到远程仓库
git push origin develop

##代码标签tag推到远程仓库
git push origin --tags


##根据tag创建修复fix-bug01分支
git checkout -b fix-bug01 v1.0.0-release

##git push 代码前先git pull如果有冲突再git merge
git pull
git merge
git push