【git】git命令和相关脚本

目录

git clone

git checkout

git diff

git diff 忽略文件权限被修改的文件

对比两个分支差异

git add

git pull --rebase

git pull 

git fetch

git reset

git stash 

git clean 

git cherry-pick

转移一个提交

转移多个提交

git merge     

git show

git log

查看某段时间内的提交

查看修改统计

查看某个文件在某次提交中的修改内容

查看某一行代码是谁写的|文件谁提交的

 查看分支合并图

git tag

git blame

git submodule update --init

git clone --recursive 

git branch

 删除分支

从已有分支拉出新分支

修改分支名称

查看某个分支的创建时间

用远程分支完全覆盖本地分支

git commit （-m多行注释）

git 删除某一次的提交（commit）

git统计

报错处理

相关脚本

git命令简写配置

---

git clone

git clone [远程仓库地址]            #clone下来保持原文件夹名

git clone [远程仓库地址]  [想要重命名的文件夹名称]  #clone重命名的文件夹名称

git checkout

git checkout迁出一个分支的特定版本。默认是迁出分支的HEAD版本

一此用法示例：

$ git checkout  master            #//取出master版本的head。

$ git checkout  tag_name         #//在当前分支上 取出 tag_name 的版本

$ git checkout  master file_name  #//放弃当前对文件file_name的修改

$ git checkout  commit_id  file_name  #//取commit_id提交版本的file_name

$ git checkout -b dev/1.5.4 origin/dev/1.5.4

# 从远程dev/1.5.4分支取得到本地分支/dev/1.5.4

$ git checkout -- hello.rb

#这条命令把hello.rb从HEAD中签出.

$ git checkout .

#这条命令把 当前目录所有修改的文件 从HEAD中签出并且把它恢复成未修改时的样子.

#注意：在使用 git checkout 时，如果其对应的文件被修改过，那么该修改会被覆盖掉。

https://www.yiibai.com/git/git_checkout.html 

git diff

git diff 忽略文件权限被修改的文件

让当前git库忽略掉文件权限检查
git config core.fileMode false

针对repo库可用如下命令解决
repo forall -c git config core.fileMode false

当前user全局设置忽略文件权限检查，可查看文件~/.gitconfig
git config --global core.fileMode false // 所有版本库
$ cat ~/.gitconfig 
[user]
    name = huping
    email = [email protected]
[http]
    postBuffer = 524288000
[core]
    compression = -1
    fileMode = false
[color]
    ui = auto

原文链接：https://blog.csdn.net/hp370440182/article/details/89278340

对比两个分支差异

1. 显示出branch1和branch2中差异的部分
git diff branch1 branch2 --stat

2. 显示指定文件的详细差异
git diff branch1 branch2 具体文件路径

3. 显示出所有有差异的文件的详细差异
git diff branch1 branch2

4. 查看branch1分支有，而branch2中没有的log
git log branch1 ^branch2

5. 查看branch2中比branch1中多提交了哪些内容
git log branch1..branch2
注意，列出来的是两个点后边（此处即dev）多提交的内容。

6. 不知道谁提交的多谁提交的少，单纯想知道有什么不一样
git log branch1...branch2

7. 在上述情况下，在显示出每个提交是在哪个分支上
git log -lefg-right branch1...branch2
注意 commit 后面的箭头，根据我们在 –left-right branch1…branch2 的顺序，左箭头 < 表示是 branch1 的，右箭头 > 表示是branch2的。

原文链接：https://blog.csdn.net/qq_42533216/article/details/121609553

git add

git add -u <==> git add –update
提交所有被删除和修改的文件到数据暂存区

git add .
提交所有修改的和新建的数据暂存区

git add -A <==>git add –all
提交所有被删除、被替换、被修改和新增的文件到数据暂存区

• git add -A 提交所有变化
• git add -u 提交被修改(modified)和被删除(deleted)文件，不包括新文件(new)
• git add . 提交新文件(new)和被修改(modified)文件，不包括被删除(deleted)文件

git版本不同会有所区别：

链接：https://www.jianshu.com/p/65fb3fa62057

---

git pull --rebase

git pull                 =  git fetch + git merge  FETCH_HEAD 
git pull --rebase =  git fetch + git rebase FETCH_HEAD 

差距就在git fetch之后的操作：

现在来看看git merge和git rebase的区别。

rebase的好处是避免了菱形的产生，保持提交曲线为直线：

在master执行git merge test,然后会得到如下结果：

       D--------E
      /          \
 A---B---C---F----G---   test, master
在master执行git rebase test，然后得到如下结果：

A---B---D---E---C‘---F‘---   test, master

详细说明：https://blog.csdn.net/bandaoyu/article/details/121507096

git pull 

一般更推荐git pull --rebase，详情见git pull --rebase

git pull 将远程主机的最新内容拉下来到本地工作目录后直接合并，即：git pull = git fetch + git merge，这样可能会产生冲突，需要手动解决。

git pull 的过程可以理解为：

git fetch origin master       //从远程主机的master分支拉取最新内容 

git merge FETCH_HEAD    //将拉取下来的最新内容合并到当前所在的分支中

即将远程主机的某个分支的更新取回，并与本地指定的分支合并，完整格式可表示为：

$ git pull  <远程主机名>  <远程分支名>:<本地分支名>

如果远程分支是与当前分支合并，则冒号后面的部分可以省略：

$ git pull origin next

//查询当前远程的版本

$ git remote -v

//直接拉取并合并最新代码

$ git pull origin master [示例1：拉取远端origin/master分支并合并到当前分支]

$ git pull origin dev [示例2：拉取远端origin/dev分支并合并到当前分支]

原文：https://blog.csdn.net/hanchao5272/article/details/79162130 

<<<<<<< HEAD

本地代码

=======

拉下来的代码

>>>>>>>

---

git fetch

git fetch将远程主机的最新内容拉到本地仓，用户在检查了以后决定是否合并到本地工作本目录

$ git fetch  <远程主机名>  //这个命令将某个远程主机的更新全部取回本地

$ git fetch  <远程主机名>  <分支名>取回特定分支的更新，可以指定分支名

$ git fetch  origin  master  最常见的命令如取回origin 主机的master 分支

取回更新后，会返回一个FETCH_HEAD ，指的是某个branch在服务器上的最新状态，我们可以在本地通过它查看刚取回的更新信息：

$ git log -p FETCH_HEAD

git fetch后的合并：
 

---

git reset

本地撤销：

reset命令有3种方式：

回退到上一个版本HEAD~1，回退到某个版本则填commit_id

git reset --soft HEAD~1：撤销add之后的操作，如果还要提交，直接commit即可

git reset --mixed HEAD~1：此为git reset不带任何参数的默认方式，只保留工作区不变，commit和add都撤销。

git reset --hard HEAD~1：仓库和本地的源码修改全部撤销，危险。

远程分支同步撤销：

git push -f origin  远程分支

说明：上面的操作都只是reset本地的，此时如果再git pull，远程仓库的内容又会和本地之前版本的内容进行merge，如果想让远程分支也reset，则需要git push -f origin 远程分支 ？

还有一种方法:直接在远程server的仓库目录下，执行git reset –soft 10efa来回退,然后本地拉下来。注意：在远程不能使用mixed或hard参数

http://t.csdn.cn/UveIa

（如何恢复因为误操作git reset --hard 删掉当前代码_https://blog.csdn.net/hourgtester/article/details/104779158）链接：https://www.jianshu.com/p/e84283d2f0f1

#回退所有内容到上一个版本

git reset HEAD^

#回退a.py这个文件的版本到上一个版本

git reset HEAD^ a.py

#向前回退到第3个版本

git reset –soft HEAD~3

#将本地的状态回退到和远程的一样

git reset –hard origin/master

#回退到某个版本

git reset 057d

#回退到上一次提交的状态，按照某一次的commit完全反向的进行一次commit

git revert HEAD

git stash 

常用git stash命令：

（1）git stash save "save message"  : 执行存储时，添加备注，方便查找，只有git stash 也要可以的，但查找时不方便识别。

（2）git stash list  ：查看stash了哪些存储

查看stash的保存时间

git stash list --date=relative

git stash list --date=short

git stash list --date=local

（3）git stash show ：显示做了哪些改动，默认show第一个存储,如果要显示其他存贮，后面加stash@{$num}，比如第二个 git stash show stash@{1}

（4）git stash show -p : 显示第一个存储的改动，如果想显示其他存存储，命令：git stash show  stash@{$num}  -p ，比如第二个：git stash show  stash@{1}  -p

（5）git stash apply :应用某个存储,但不会把存储从存储列表中删除，默认使用第一个存储,即stash@{0}，如果要使用其他个，git stash apply stash@{$num} ， 比如第二个：git stash apply stash@{1} 

（6）git stash pop ：

命令恢复之前缓存的工作目录，将缓存堆栈中的对应stash删除，并将对应修改应用到当前的工作目录下,默认为第一个stash,即stash@{0}，如果要应用并删除其他stash，命令：git stash pop stash@{$num} ，比如应用并删除第二个：git stash pop stash@{1}

用git stash pop 一旦出现冲突，git会认为stash没有结束，导致git stash list 中的列表依然存在实际已经pop出过的记录。

处理的方式：丢弃对应的记录:git stash drop  如果不加stash编号，默认的就是删除最新的，也就是编号为0的那个

（7）git stash drop stash@{$num} ：丢弃stash@{$num}存储，从列表中删除这个存储

（8）git stash clear ：删除所有缓存的stash

git stash list

git stash show

git stash show -p

git stash show -p stash@{1}

 git 删除stash

git stash drop stash@{0} 

git clean 

删除git库中untracked files（未监控）的文件

# 删除 untracked files

git clean -f       

git  clean  -f                  #将所有untracked file 一次性删除

# 删除 untracked files和目录（d）也一起删掉
git clean -fd   

# 删除当前目录下所有没有track过的文件. 不管他是否是.gitignore文件里面指定的文件夹和文件
# 连 gitignore 的untrack 文件/目录也一起删掉 （慎用，一般这个是用来删掉编译出来的 .o之类的文件用的）

git clean -xf     #文件
git clean -xfd   #文件/目录也一起删掉

 
# 在用上述 git clean 前，强烈建议加上 -n 先看看会删掉哪些文件，n是一次clean的演习, 告诉你哪些文件会被删除. 他不会真正的删除文件, 只是一个提醒
git clean -nxfd
git clean -nf
git clean -nfd

原文链接：https://blog.csdn.net/RonnyJiang/article/details/53507306

注意：

不加上x参数，是不会删除被ignore的文件或目录的。但是如果你在.gitignore文件中对目录的描述是dir/*那么很抱歉，这个目录及里面的文件也会被清除掉。即使该目录的确是被git所忽略的。

usage: git clean [-d] [-f] [-n] [-q] [-x | -X] [--] ...
 
    -q, --quiet           be quiet（静默删除，只会告诉你出错信息。如果是成功删除了文件或目录则保持沉默）
    -n, --dry-run         dry run（告诉你会被删除的文件或目录有哪些，删除文件毕竟是一件严肃的事，在执行该命令前请务必加上该参数先确定下）
    -f, --force           force（强制删除，clean.requireForce默认的值是true。这种情况下只有加上该参数才能删除）
    -d                    remove whole directories（删除的范围是整个目录）
    -x                    remove ignored files, too（即使是被添加进gitignore的文件或目录也删掉。这里有坑，下面说~）
    -X                    remove only ignored files（只删除被添加进gitignore的文件或目录）

git reset --hard和git clean -f是一对好基友. 结合使用他们能让你的工作目录完全回退到最近一次commit的时候

git clean对于刚编译过的项目也非常有用. 如, 他能轻易删除掉编译后生成的.o和.exe等文件. 这个在打包要发布一个release的时候非常有用

下面的例子要删除所有工作目录下面的修改, 包括新添加的文件. 假设你已经提交了一些快照了, 而且做了一些新的开发

git reset --hard

git clean -df

链接：https://www.jianshu.com/p/0b05ef199749
 

git cherry-pick

简单讲：就是pick 一个分支上的commit，贴到另外一个分支上。

转移一个提交

 代码仓库有master和feature两个分支
    a - b - c - d   Master
         \
           e - f - g Feature

Feature上有个f提交,现在master也想要这个f提交。

 
# 切换到 master 分支
$ git checkout master
 
# Cherry pick 操作
$ git cherry-pick  f

上面的操作完成以后，代码库就变成了下面的样子。

  a - b - c - d - f   Master
         \
           e - f - g Feature

git cherry-pick命令的参数，不一定是提交的哈希值，分支名也是可以的，表示转移该分支的最新提交。

 
$ git cherry-pick feature

转移多个提交

将某几个commit 拉到本分支（转移多个提交）

列出commit list

#将 A 和 B 两个提交应用到当前分支。

git cherry-pick   

# 转移从 A(含A） 到 B 的所有提交。

git cherry-pick A^..B

git cherry-pick [commit_id0^,commit_idn]

# 转移从 A(不含A） 到 B 的所有提交。

git cherry-pick A..B 

git cherry-pick (commit_id0,commit_idn]

*它们必须按照正确的顺序放置：提交 A 必须早于提交 B，否则命令将失败，但不会报错。

如果原始提交是一个合并节点，来自于两个分支的合并，那么 Cherry pick 默认将失败，因为它不知道应该采用哪个分支的代码变动。

-m配置项告诉 Git，应该采用哪个分支的变动。它的参数parent-number是一个从1开始的整数，代表原始提交的父分支编号。

git cherry-pick -m 1

上面命令表示，Cherry pick 采用提交commitHash来自编号1的父分支的变动。

一般来说，1号父分支是接受变动的分支（the branch being merged into），2号父分支是作为变动来源的分支（the branch being merged from）。

代码冲突

如果操作过程中发生代码冲突，Cherry pick 会停下来，让用户决定如何继续操作。

（1）--continue

用户解决代码冲突后，第一步将修改的文件重新加入暂存区（git add .），第二步使用下面的命令，让 Cherry pick 过程继续执行。

$ git cherry-pick --continue

（2）--abort

发生代码冲突后，放弃合并，回到操作前的样子。

（3）--quit

发生代码冲突后，退出 Cherry pick，但是不回到操作前的样子。

转移到另一个代码库

Cherry pick 也支持转移另一个代码库的提交，方法是先将该库加为远程仓库。

$ git remote add target git://gitUrl

上面命令添加了一个远程仓库target。

然后，将远程代码抓取到本地。

$ git fetch target

上面命令将远程代码仓库抓取到本地。

接着，检查一下要从远程仓库转移的提交，获取它的哈希值。

$ git log target/master

最后，使用git cherry-pick命令转移提交。

$ git cherry-pick

git merge     

方式1：

#把master的megre到feature

git  checkout  feature
git  merge      master

merge合并的优点：

• 自动创建一个新的commit，记录了真实的commit情况，方便查看记录
• 如果合并遇到冲突，仅需要修改后重新commit即可

merge的缺点：就是每次合并都会产生一个新的commit, 所以在使用一些git的 GUI工具，特别是commit比较频繁时，就会看到分支线很杂乱。这时如果有问题需要查找就会很困难。

方式2：

#把master的rebase到feature，就是把master的commit安插到feature线上

git  checkout  feature
git  rebase     master

git merge和rebase合并分支的区别：https://www.cnblogs.com/shenjp/p/14437454.html

如上图所示，rebase的特点：

• 改变当前分支从master上拉出分支
• 没有多余的合并历史记录，并且合并后的commit顺序不一定按照commit的提交时间排序
• 可能会多次解决同一个地方的冲突
• 提交记录更干净，master上每个commit点都是相对独立完整的功能点

假如我们在rebase的过程中遇到了冲突，我们在解决冲突之后，需要执行:

1. git add

2.  git rebase --continue 来继续变基的操作。

3. 如果执行第二步无效，那么可以执行 git rebase --skip

注意：不要执行完 git add 之后执行 git commit

git分支合并：https://www.cnblogs.com/alice-cj/p/11300652.html

git show

查看某次提交/更新所更改的文件及内容

git show commit_id --stat     #查看更改了哪几个文件 

git show commit_id     #查看更改了什么内容

.查看最近5条更新日志，并且简单显示出所涉及的文件:

git log -5 --stat

--name-only: 仅在提交信息后显示已修改的文件清单。

git log --name-only

git log

git log      可以显示所有提交过的版本信息，不包括已经被删除的 commit 记录和 reset 的操作

git log --

git reflog  是显示所有的操作记录，包括提交，回退的操作。一般用来找出操作记录中的版本号，进行回退。git reflog  常用于恢复本地的错误操作。

git log --author="author"   查找某一个作者所有的提交

查看某段时间内的提交

git log --since='2021-05-21' --until='2021-05-28'   #查询一定时间范围的日志

git show commitId            查看某次commit的内容

git log -p -n        查看最近几次提交的修改内容，n为数字，表示最近n次的修改内容

git log --reverse  逆序  

git shortlog --format='%H|%cn|%s' | grep '#2230'           查找commit里面包含某些字符的log日志
git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr)%Creset' --abbrev-commit --date=relative     查看定制化显示效果:

查看修改统计

--stat   显示每次更新的文件修改统计信息，会列出具体文件列表

--shortstat    统计每个commit 的文件修改行数，包括增加，删除，但不列出文件列表：  

--numstat   统计每个commit 的文件修改行数，包括增加，删除，并列出文件列表：

-p 选项展开显示每次提交的内容差异，用 -2 则仅显示最近的两次更新

       例如：git log -p  -2

--name-only 仅在提交信息后显示已修改的文件清单

--name-status 显示新增、修改、删除的文件清单

原文链接：https://blog.csdn.net/jiangjsf/article/details/83686749

查看某个文件在某次提交中的修改内容

git  show  :

 git  diff  <commit-hash>^! <file-path>

查看某一行代码是谁写的|文件谁提交的

git blame index.js    #查询index.js文件的提交记录

git blame -L 5,9  文件名    #查文件第 5 行到第 9 行的提交记录

 查看分支合并图

 git log --graph

git log 来显示 commit date 而不是 author date 

git log --pretty = fuller - 这会显示两个日期。如果您只想查看一个日期，但将其作为提交日期，则可以使用 git log --format =< some stuff> 。用于定义格式的所有允许代码均记录在 git help log 。提交日期是％cd ，％cD ，％cr ，％ct 或％ci 

git log --since='2021-05-21' --until='2021-05-28' --format='%aN' | sort -u | while read name; do echo -en "$name,";

git log --since='2021-05-21' --until='2021-05-28' --author="$name" --numstat --pretty=tformat: --no-merges | awk '{ add += $1; subs += $2; loc += $1 - $2 } END { printf "added lines, %s, removed lines, %s, total lines, %s\n", add, subs, loc }' -; done >> 21_05_28_code.csv;

since定义其实时间，until定义结束时间。

原文链接：https://blog.csdn.net/m0_43383623/article/details/119342633

git tag

查看本地的tag          git tag

在本地打一个tag      git tag   1-25       

删除本地tag             git tag   -d  1 25

创建的标签都只存储在本地，不会自动推送到远程。所以，打错的标签可以在本地安全删除。

如果要推送某个标签到远程，使用命令 git push origin 1-25

推送多个本地tag至远程 git push origin --tags

删除tag，已经推送至远程的，可以先删除本地的，再删除远程的 git push origin :refs/tags/1-25

删除tag 或者使用： git push origin :111

切换到某个tag对应的代码：git checkout

原文链接：https://blog.csdn.net/qq_37304462/article/details/113159241

git blame

查看某一行代码的修改历史:谁修改的git blame
查看某行代码谁写的：

git blame file_name
git blame -L 58,100 file_name  # 58~100   行代码
git blame -L 58,+20 file_name  # 58~58+20 行代码
其输出格式为：

commit_ID | 代码提交作者 | 提交时间 | 代码位于文件中的行数 | 实际代码 

git submodule update --init

git clone --recursive 

仓库一起拉取：

git clone --recurse-submodules 父仓库地址

分开拉取：

git clone 父仓库地址

git submodule init // 初始化子模块
git submodule update // 更新子模块与主仓库中的子模块代码同步
// or
git submodule update --init
// or 嵌套的(子仓库中包含子仓库)
git submodule update --init --recursive

 更新、拉取子仓库代码方法：

父目录中：

$ git submodule update // 与主仓库中的子模块代码同步
$ git submodule update --remote // 与子仓库中代码同步（同步所有的子模块）
$ git submodule update --remote xxx // 指定需要同步的子模块

下载子模块

​git clone --recursive https://github.com/Cambricon/CNStream

或

​git clone https://github.com/Cambricon/CNStream
cd CNStream
git submodule update --init

方法一：git clone --recursive 

方法二：git submodule update --init

（子模块更多内容：Git必备命令-子模块--https://mp.weixin.qq.com/s?__biz=MzA5MDIyNTM3Mw==&mid=2666581388&idx=1&sn=1a7442163d87649b6dd1a4c8d70acd73&chksm=8b0a823ebc7d0b2823466d68a70c2510ea42a9cad37d3d40b113eb2353a6b462eab5931a71b5&scene=27)

git branch

git branch <分支名> 创建新分支

git switch <分支名>  切换分支

git checkout <分支名> 切换分支

git checkout -b <分支名>：创建并切换分支（旧版本）

git switch -c <分支名>：创建并切换分支（推荐使用）

git branch -a:查看本地、远程分支（远程分支为红色）

git merge <分支名>  合并分支到当前分支

 删除分支

$git branch -d  分支名  //删除本地分支

$git push origin -d 分支名 //删除远程分支

从已有分支拉出新分支

从 master 分支，重新拉取出名为 dev的新分支

 git checkout master

git pull

git checkout -b dev   #从当前分支 copy 出新的开发分支

git push origin dev    #把新建的分支 push 到远端

git branch --set-upstream-to=origin/dev   #本地分支与远程分支关联

修改分支名称

使用git命令操作
1、修改本地分支名称
git branch -m oldBranchName newBranchName

2、将本地分支的远程分支删除
git push --delete origin oldBranchName

3、将改名后的本地分支推送到远程，并将本地分支与之关联
git push --set-upstream origin newBranchName

原文链接：https://blog.csdn.net/weixin_42343307/article/details/125648147

查看某个分支的创建时间

git reflog show --date=iso

用远程分支完全覆盖本地分支

首先，确保你已经将本地分支推送至远程仓库，或者你对本地分支修改的部分可以被丢弃，因为此操作会完全覆盖本地分支。
git fetch origin
git reset --hard origin/

git commit （-m多行注释）

方法1：多个-m
git  -m "commit title" -m "commit description"

方法2：打开一个双引号，每一行回车，直到最后一行再加双引号，回车。

git commit -m "commit title
>
> commit description"

git 删除某一次的提交（commit）

（参考：git 删除某一次的提交（commit））

1、git log，查看提交记录，找到你要删除的commit，找到需要删除比他更早的最近的commitid。

2、git rebase -i 目标commitid  回车，进入了文件操作界面，需要编辑，（编辑模式是敲i，即可进入编辑状态）找到要删除的commitid ，将commitid 前面的pick修改成drop，表示放弃它，看到的结果如下图：

 3、退出编辑模式，然后按Shift+“;”，再输入wq!

4、然后推送到远端git push --force，这样就完成了删除指定提交的操作，再打印log，看到要删除的那个commitid已经不在了。 （要考虑清除，是force直接覆盖了分支）

git统计

1. git diff HEAD~2 获取最近两次提交的具体不同 包括增删的文件以及行数以及每行具体的改动

     git diff HEAD~2   --stat

2.  git diff --stat 获取文件更改的个数 增加行数 删除行数

3. git diff --numstat 表格形式获取增加行数和减少行数

报错处理

【GIT】git 错误记录；https://blog.csdn.net/bandaoyu/article/details/115550048

相关脚本

git status |grep  "modified"|awk  '{print $3}'|args -I {}  git add {}

git常用操作（branch tag）https://blog.csdn.net/zack_liu/article/details/112467635

git命令简写配置

在git中敲命令，将这些简写添加到git配置中,https://www.cnblogs.com/kuyuecs/p/7111749.html

[alias]
    st = status
    co = checkout
    br = branch
    mg = merge
    ci = commit 
    md = commit --amend
    dt = difftool
    mt = mergetool
    last = log -1 HEAD
    cf = config
    line = log --oneline
    latest = for-each-ref --sort=-committerdate --format='%(committerdate:short) %(refname:short) [%(committername)]'

    ls = log --pretty=format:\"%C(yellow)%h %C(blue)%ad %C(red)%d %C(reset)%s %C(green)[%cn]\" --decorate --date=short
    hist = log --pretty=format:\"%C(yellow)%h %C(red)%d %C(reset)%s %C(green)[%an] %C(blue)%ad\" --topo-order --graph --date=short
    type = cat-file -t
    dump = cat-file -p
 

#创建新分支=================gcb 
cat > /usr/local/bin/gcb << 'EOF'
#!/bin/bash
set -e
if [ $# -eq 0 ];then
echo "No input branch name"
exit 1
fi
BRANCH=$1
git checkout -b ${BRANCH}   #从当前分支 copy 出新的开发分支
git push origin ${BRANCH}    #把新建的分支 push 到远端
git branch --set-upstream-to=origin/${BRANCH} ${BRANCH} #本地分支与远程分支关联

EOF
chmod +x /usr/local/bin/gcb



#删除分支==================gdel 
cat > /usr/local/bin/gdel << 'EOF'
#!/bin/bash
set -e
if [ $# -eq 0 ];then
echo "No input branch name"
exit 1
fi
BRANCH=$1
CURRENT_BRANCH=$(git branch |grep "*"|awk '{print $2}')

if [[  "${BRANCH}" == "master"  ]];then
echo "Sorry, delete master is not allow."
fi


if [[  "${BRANCH}" == "${CURRENT_BRANCH}"  ]];then
git checkout master
fi

read -p "Are you sure del ${BRANCH}:" answer

if [[ "${answer}" == "y" ]] || [[ "${answer}" == "Y" ]]; then

git branch -d  ${BRANCH}  #删除本地分支
git push origin -d ${BRANCH} #删除远程分支
else
 echo "Your input is not 'Y' or 'y',delete canceled."
fi

EOF
chmod +x /usr/local/bin/gdel


#创建新分支=================gck

cat > /usr/local/bin/gck << 'EOF'
#!/bin/bash
set -e
if [ $# -eq 0 ];then
echo "No input branch name"
exit 1
fi
BRANCH=$1
git checkout  ${BRANCH}   #从当前分支 copy 出新的开发分支

EOF
chmod +x /usr/local/bin/gck


cat > /usr/local/bin/gb << 'EOF'
#!/bin/bash
git branch ${@}   #从当前分支 copy 出新的开发分支

EOF
chmod +x /usr/local/bin/gb

#重命名分支===================grename 
cat > /usr/local/bin/grename << 'EOF'
#!/bin/bash
set -e
if [ $# -lt 2 ];then
echo "No input branch name and new name"
exit 1
fi
oldBranchName=$1
newBranchName=$2

read -p "Are you sure rename \"${oldBranchName}\" to \"${newBranchName}\":" answer

if [[ "${answer}" == "y" ]] || [[ "${answer}" == "Y" ]]; then

##修改本地分支名称
git branch -m ${oldBranchName} ${newBranchName}

##将本地分支的远程分支删除
git push --delete origin ${oldBranchName}

##将改名后的本地分支推送到远程，并将本地分支与之关联
git push --set-upstream origin ${newBranchName}

else
 echo "Your input is not 'Y' or 'y',rename canceled."
fi

EOF
chmod +x /usr/local/bin/grename