git 使用

http://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/001374385852170d9c7adf13c30429b9660d0eb689dd43a000

git 使用指南：  http://www.bootcss.com/p/git-guide/

clone一个源：

＃git  clone https://github.com/stefanalund/openwebrtc-examples

看看更新历史：

#gitk &

#git log

用git grep命令查找Git库里面的某段文字是很方便的

$>git grep -n xmmap    显示行号, 你可以添加'-n'选项:
$git grep --name-only xmmap   只显示文件名, 我们可以使用'--name-onley'选项:
$git grep -c xmmap  #用'-c'选项,可以查看每个文件里有多少行匹配内容(line matches):
$git grep xmmap v1.5.0  查找git仓库里某个特定版本里的内容$
$ git grep -e '#define' --and -e SORT_DIRENT     查找我们在仓库的哪个地方定义了'SORT_DIRENT'.
$ git grep --all-match -e '#define' -e SORT_DIRENT    "或"(either)条件搜索操作.
$ git grep -e '#define' --and \( -e PATH -e MAX \)    查找出符合一个条件(term)且符合两个条件(terms)之一的文件行.　例如我们要找出名字中含有‘PATH'或是'MAX'的常量定义:

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  //取文件file_name的 在commit_id是的版本。commit_id为 git commit 时的sha值。

git checkout .  这条命令把 当前目录所有修改的文件 从HEAD中签出并且把它恢复成未修改时的样子.  注意：在使用git checkout 时，如果其对应的文件被修改过，那么该修改会被覆盖掉。

查看源：

$ git remote -v

origin https://github.com/stefanalund/openwebrtc-examples (fetch)

origin https://github.com/stefanalund/openwebrtc-examples (push)

$ cat .git/config 

[core]

repositoryformatversion = 0

filemode = true

bare = false

logallrefupdates = true

ignorecase = true

precomposeunicode = true

[remote "origin"]

url = https://github.com/stefanalund/openwebrtc-examples

fetch = +refs/heads/*:refs/remotes/origin/*

[branch "master"]

remote = origin

merge = refs/heads/master

更新到最新的 version：

＃git pull --rebase 
Current branch master is up to date.

 git fetch：相当于是从远程获取最新版本到本地，不会自动merge

git fetch origin master

git log -p master..origin/master
git merge origin/master
    以上命令的含义：
   首先从远程的origin的master主分支下载最新的版本到origin/master分支上
   然后比较本地的master分支和origin/master分支的差别
   最后进行合并
   上述过程其实可以用以下更清晰的方式来进行：

git fetch origin master:tmp
git diff tmp 
git merge tmp
    从远程获取最新的版本到本地的test分支上
   之后再进行比较合并

你可以使用如下命令替换掉本地改动：

git checkout -- <filename>

此命令会使用 HEAD 中的最新内容替换掉你的工作目录中的文件。已添加到缓存区的改动，以及新文件，都不受影响。

 你可以使用如下命令替换掉本地改动：

git pull

要合并其他分支到你的当前分支（例如 master），执行：
git merge <branch>

假如你想要丢弃你所有的本地改动与提交，可以到服务器上获取最新的版本并将你本地主分支指向到它：

git fetch origin

git reset --hard origin/master

git pull：相当于是从远程获取最新版本并merge到本地

git pull origin master

上述命令其实相当于git fetch 和 git merge
在实际使用中，git fetch更安全一些
因为在merge前，我们可以查看更新情况，然后再决定是否合并

标签:
$ git tag stable-1 1b2e1d63ff     轻量级标签
$ git tag -a stable-1 1b2e1d63ff    标签对象
$ git tag -u <gpg-key-id> stable-1 1b2e1d63ff   签名的标签

git revert and reset;

git revert 是撤销某次操作，此次操作之前的commit都会被保留
git reset 是撤销某次提交，但是此次之后的修改都会被退回到暂存区
具体一个例子，假设有三个commit， git st:
commit3: add test3.c
commit2: add test2.c
commit1: add test1.c
当执行git revert HEAD~1时， commit2被撤销了
git log可以看到：
commit1：add test1.c
commit3：add test3.c
git status 没有任何变化


如果换做执行git reset --soft(默认) HEAD~1后，运行git log
commit2: add test2.c
commit1: add test1.c
运行git status， 则test3.c处于暂存区，准备提交。


如果换做执行git reset --hard HEAD~1后，
显示：HEAD is now at commit2，运行git log
commit2: add test2.c
commit1: add test1.c
运行git st， 没有任何变化

另外：
git revert <commit log string>是撤消该commit，作为一个新的commit。

#git reset <commit-id>   #reset  到某个 commit-id；  commit-id 之后的修改会被放入  暂存区保存；

#git reset   --hard   <commit-id>   #reset  到某个 commit-id；    commit-id 之后的修改会被清空！！！； 包含其他的暂存区文件；

#git reset --hard放弃所有自己的修改， 包含其他的暂存区文件；

#git pull     //更新到最新

#git reset HEAD filename  # 从暂存区移除文件；

#git reset HEAD~3    # 最近3次提交全部重置；就像没有提交过一样；

#git reset --hard  <commit-id>    重置到commit-id 的地方；

#git reset --hard <commit-id>   重置到commit-id 的地方；

#git branch leo_test // 从commit-id 处 创建新的branch leo_test

#git checkout leo_test //切换到新创建的branch；

#gitk //查看branch 的历史记录

git branch:

$ git branch -a    查看远程分支    查看本地和远程分支  -a。前面带*号的代表你当前工作目录所处的分支
$ git branch     查看本地分支
$ git branch test    创建分支
$ git push origin test    把分支推到远程分支 
$ git checkout test   切换分支到test
$ git br -d test  删除本地分支   git branch -d xxxxx
$ git push origin :br-1.0.0   删除远程版本

查看当前的远程库

$ git remote
my_remote_test
origin

$git remote -v
my_remote_test  https://github.com/bamboolsu/my_test_mot (fetch)
my_remote_test  https://github.com/bamboolsu/my_test_mot (push)
origin  https://github.com/bamboolsu/my_test_mot (fetch)
origin  https://github.com/bamboolsu/my_test_mot (push)

添加远程仓库

$ git remote add my_remote_test   https://github.com/bamboolsu/my_test_mot

$ git fetch  my_remote_test

一、git clone

$ git clone <版本库的网址>   

$ git clone https://github.com/jquery/jquery.git
$ git clone <版本库的网址> <本地目录名>   
该命令会在本地主机生成一个目录，与远程主机的版本库同名。如果要指定不同的目录名，可以将目录名作为git clone命令的第二个参数。

$ git clone http[s]://example.com/path/to/repo.git/$ git clone ssh://example.com/path/to/repo.git/$ git clone git://example.com/path/to/repo.git/$ git clone /opt/git/project.git $ git clone file:///opt/git/project.git$ git clone ftp[s]://example.com/path/to/repo.git/$ git clone rsync://example.com/path/to/repo.git/

$ git clone [user@]example.com:path/to/repo.git/

二、git remote

$ git remote -v   使用-v选项，可以参看远程主机的网址。

$ git clone -o jQuery https://github.com/jquery/jquery.git   //克隆版本库的时候，所使用的远程主机自动被Git命名为origin。如果想用其他的主机名，需要用git clone命令的-o选项指定。$ git remotejQuery

$ git remote show <主机名>   //git remote show命令加上主机名，可以查看该主机的详细信息。
$ git remote add <主机名> <网址>   //git remote add命令用于添加远程主机。
$ git remote rm <主机名>   //git remote rm命令用于删除远程主机。
$ git remote rename <原主机名> <新主机名>   //git remote rename命令用于远程主机的改名。
三、git fetch
$ git fetch <远程主机名>    //一旦远程主机的版本库有了更新（Git术语叫做commit），需要将这些更新取回本地，这时就要用到git fetch命令   默认情况下，git fetch取回所有分支（branch）的更新。
$ git fetch <远程主机名> <分支名>   //如果只想取回特定分支的更新，可以指定分支名。
$ git fetch origin master  //取回origin主机的master分支。
$ git branch -r  //git branch命令的-r选项，可以用来查看远程分支，
$ git branch -a  //-a选项查看所有分支。
* master  remotes/origin/master
//上面命令表示，本地主机的当前分支是master，远程分支是origin/master。
$ git checkout -b newBrach origin/master  //上面命令表示，在origin/master的基础上，创建一个新分支。
$ git merge origin/master# 或者$ git rebase origin/master
上面命令表示在当前分支上，合并origin/master。
四、git pull
$ git pull <远程主机名> <远程分支名>:<本地分支名>  //git pull命令的作用是，取回远程主机某个分支的更新，再与本地的指定分支合并。它的完整格式稍稍有点复杂。
$ git pull origin next:master   //比如，取回origin主机的next分支，与本地的master分支合并。
$ git pull origin next   //如果远程分支是与当前分支合并，则冒号后面的部分可以省略。
========  $ git fetch origin
         $ git merge origin/next
#git branch --set-upstream master origin/next   //Git也允许手动建立追踪关系。  Git会自动在本地分支与远程分支之间，建立一种追踪关系（tracking

$ git pull origin     //本地的当前分支自动与对应的origin主机"追踪分支"（remote-tracking branch）进行合并。

$ git pull   //当前分支自动与唯一一个追踪分支进行合并。

$ git pull --rebase <远程主机名> <远程分支名>:<本地分支名>   //如果合并需要采用rebase模式，可以使用--rebase选项。

五、git push

git push命令用于将本地分支的更新，推送到远程主机。它的格式与git pull命令相仿。

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

$ git push origin master  //如果省略远程分支名，则表示将本地分支推送与之存在"追踪关系"的远程分支（通常两者同名），如果该远程分支不存在，则会被新建。

$ git push origin bbbb   ==== $ git push origin bbbb:bbbb   //把本地分支  push  到 服务器端 分支，  之后其他协作者就可以pull下来使用了，

$ git push origin :master  # 等同于  $ git push origin --delete master   //上面命令表示删除origin主机的master分支。

$ git push origin  // 将当前分支推送到origin主机的对应分支。
$ git push    //如果当前分支只有一个追踪分支，那么主机名都可以省略。
$ git push -u origin master  //上面命令将本地的master分支推送到origin主机，同时指定origin为默认主机，后面就可以不加任何不带任何参数的git push，
$ git push  //默认只推送当前分支，这叫做simple方式。参数使用git push了。
$ git config --global push.default matching  # 或者 $ git config --global push.default simple
$ git push --all origin  //还有一种情况，就是不管是否存在对应的远程分支，将本地的所有分支都推送到远程主机，这时需要使用--all选项
$ git push --force origin  //如果远程主机的版本比本地版本更新，推送时Git会报错，要求先在本地做git pull合并差异，然后再推送到远程主机。这时，如果你一定要推送，可以使用--force选项。
$ git push origin --tags  //git push不会推送标签（tag），除非使用--tags选项。

操练：

安装完成后，还需要最后一步设置，在命令行输入：

$ git config --global user.name "Your Name"$ git config --global user.email "[e-mail]"

git config命令的--global参数，用了这个参数，表示你这台机器上所有的Git仓库都会使用这个配置

 #cat   ~/.gitconfig  

#mkdir /mnt/my_git_repo

#cd /mnt/my_git_repo

#git inti

#vim 1.txt   //modify it

#git add 1.txt

#git commit  -m  "add 1.txt"

#vim 1.txt //modify it again;

#git add . ;  你又理解了Git是如何跟踪修改的，每次修改，如果不add到暂存区，那就不会加入到commit中。

#git status

#git commit -m "modify it.

#git status

git status命令可以让我们时刻掌握仓库当前的状态

#git diff

#git diff 1.txt

#git loggit log命令显示从最近到最远的提交日志，我们可以看到3次提交，

$ git log --pretty=oneline 如果嫌输出信息太多，看得眼花缭乱的，可以试试加上--pretty=oneline参数：

#git reset --hard HEAD^

首先，Git必须知道当前版本是哪个版本，在Git中，用HEAD表示当前版本，也就是最新的提交3628164...882e1e0（注意我的提交ID和你的肯定不一样），上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100。

$ git reset --hard 3628164   版本号没必要写全，前几位就可以了，Git会自动去找。

$ git checkout -- readme.txt  
命令git checkout -- readme.txt意思就是，把readme.txt文件在工作区的修改全部撤销，命令中的--很重要，没有--，就变成了“切换到另一个分支”的命令. 这里有两种情况：
一种是readme.txt自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；
一种是readme.txt已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。
总之，就是让这个文件回到最近一次git commit或git add时的状态。

在commit之前，你发现了这个问题。用git status查看一下，修改只是添加到了暂存区，还没有提交：

Git同样告诉我们，用命令git reset HEAD file可以把暂存区的修改撤销掉（unstage），重新放回工作区：

$ git checkout -- readme.txt   还记得如何丢弃工作区的修改吗？

场景1：当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令git checkout -- file。

场景2：当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令git reset HEAD file，就回到了场景1，第二步按场景1操作。

删除：

$ git rm test.txtrm 'test.txt'$ git commit -m "remove test.txt"

另一种情况是删错了，因为版本库里还有呢，所以可以很轻松地把误删的文件恢复到最新版本：
$ git checkout -- test.txt
git checkout其实是用版本库里的版本替换工作区的版本，无论工作区是修改还是删除，都可以“一键还原”。

远程操作：

$ git push origin master

把本地master分支的最新修改推送至GitHub，现在，你就拥有了真正的分布式版本库！

$ git clone [e-mail]:michaelliao/gitskills.git   我们勾选Initialize this repository with a README，这样GitHub会自动为我们创建一个README.md文件。创建完毕后，可以看到README.md文件：

GitHub给出的地址不止一个，还可以用https://github.com/michaelliao/gitskills.git这样的地址。实际上，Git支持多种协议，默认的git://使用ssh，但也可以使用https等其他协议。

使用https除了速度慢以外，还有个最大的麻烦是每

分支管理：

首先，我们创建dev分支，然后切换到dev分支：

$ git checkout -b devSwitched to a new branch 'dev'

git checkout命令加上-b参数表示创建并切换，相当于以下两条命令：

$ git branch dev$ git checkout devSwitched to branch 'dev'

然后，用git branch命令查看当前分支：

$ git branch* dev  master

git branch命令会列出所有分支，当前分支前面会标一个*号。

然后提交：

$ git add readme.txt $ git commit -m "branch test"[dev fec145a] branch test 1 file changed, 1 insertion(+)

现在，dev分支的工作完成，我们就可以切换回master分支：

$ git checkout masterSwitched to branch 'master'

切换回master分支后，再查看一个readme.txt文件，刚才添加的内容不见了！因为那个提交是在dev分支上，而master分支此刻的提交点并没有变：

$ git merge devUpdating d17efd8..fec145aFast-forward readme.txt |    1 + 1 file changed, 1 insertion(+)

git merge命令用于合并指定分支到当前分支。合并后，再查看readme.txt的内容，就可以看到，和dev分支的最新提交是完全一样的。

注意到上面的Fast-forward信息，Git告诉我们，这次合并是“快进模式”，也就是直接把master指向dev的当前提交，所以合并速度非常快。

当然，也不是每次合并都能Fast-forward，我们后面会将其他方式的合并。

合并完成后，就可以放心地删除dev分支了：

$ git branch -d devDeleted branch dev (was fec145a).

删除后，查看branch，就只剩下master分支了：

$ git branch* master

因为创建、合并和删除分支非常快，所以Git鼓励你使用分支完成某个任务，合并后再删掉分支，这和直接在master分支上工作效果是一样的，但过程更安全。

解决冲突

$ git checkout -b feature1Switched to a new branch 'feature1'

修改readme.txt最后一行，改为：

Creating a new branch is quick AND simple.

在feature1分支上提交：

$ git add readme.txt $ git commit -m "AND simple"[feature1 75a857c] AND simple 1 file changed, 1 insertion(+), 1 deletion(-)

切换到master分支：

$ git checkout masterSwitched to branch 'master'Your branch is ahead of 'origin/master' by 1 commit.

Git还会自动提示我们当前master分支比远程的master分支要超前1个提交。

在master分支上把readme.txt文件的最后一行改为：

Creating a new branch is quick & simple.

提交：

$ git add readme.txt $ git commit -m "& simple"[master 400b400] & simple 1 file changed, 1 insertion(+), 1 deletion(-)

现在，master分支和feature1分支各自都分别有新的提交，变成了这样：

这种情况下，Git无法执行“快速合并”，只能试图把各自的修改合并起来，但这种合并就可能会有冲突，我们试试看：

$ git merge feature1Auto-merging readme.txtCONFLICT (content): Merge conflict in readme.txtAutomatic merge failed; fix conflicts and then commit the result.

果然冲突了！Git告诉我们，readme.txt文件存在冲突，必须手动解决冲突后再提交。git status也可以告诉我们冲突的文件：

$ git status# On branch master# Your branch is ahead of 'origin/master' by 2 commits.## Unmerged paths:#   (use "git add/rm <file>..." as appropriate to mark resolution)##       both modified:      readme.txt#no changes added to commit (use "git add" and/or "git commit -a")

我们可以直接查看readme.txt的内容：

Git is a distributed version control system.Git is free software distributed under the GPL.Git has a mutable index called stage.Git tracks changes of files.<<<<<<< HEADCreating a new branch is quick & simple.=======Creating a new branch is quick AND simple.>>>>>>> feature1

Git用<<<<<<<，=======，>>>>>>>标记出不同分支的内容，我们修改如下后保存：

Creating a new branch is quick and simple.

再提交：

$ git add readme.txt $ git commit -m "conflict fixed"[master 59bc1cb] conflict fixed

现在，master分支和feature1分支变成了下图所示：

用带参数的git log也可以看到分支的合并情况：

$ git log --graph --pretty=oneline --abbrev-commit*   59bc1cb conflict fixed|\| * 75a857c AND simple* | 400b400 & simple|/* fec145a branch test...

最后，删除feature1分支：

$ git branch -d feature1Deleted branch feature1 (was 75a857c).

分支管理策略：

通常，合并分支时，如果可能，Git会用Fast forward模式，但这种模式下，删除分支后，会丢掉分支信息。

如果要强制禁用Fast forward模式，Git就会在merge时生成一个新的commit，这样，从分支历史上就可以看出分支信息。

下面我们实战一下--no-ff方式的git merge：

首先，仍然创建并切换dev分支：

$ git checkout -b devSwitched to a new branch 'dev'

修改readme.txt文件，并提交一个新的commit：

$ git add readme.txt $ git commit -m "add merge"[dev 6224937] add merge 1 file changed, 1 insertion(+)

现在，我们切换回master：

$ git checkout masterSwitched to branch 'master'

准备合并dev分支，请注意--no-ff参数，表示禁用Fast forward：

$ git merge --no-ff -m "merge with no-ff" devMerge made by the 'recursive' strategy. readme.txt |    1 + 1 file changed, 1 insertion(+)

因为本次合并要创建一个新的commit，所以加上-m参数，把commit描述写进去。

合并后，我们用git log看看分支历史：

$ git log --graph --pretty=oneline --abbrev-commit*   7825a50 merge with no-ff|\| * 6224937 add merge|/*   59bc1cb conflict fixed...

可以看到，不使用Fast forward模式，merge后就像这样：

分支策略

在实际开发中，我们应该按照几个基本原则进行分支管理：

首先，master分支应该是非常稳定的，也就是仅用来发布新版本，平时不能在上面干活；

那在哪干活呢？干活都在dev分支上，也就是说，dev分支是不稳定的，到某个时候，比如1.0版本发布时，再把dev分支合并到master上，在master分支发布1.0版本；

你和你的小伙伴们每个人都在dev分支上干活，每个人都有自己的分支，时不时地往dev分支上合并就可以了。

所以，团队合作的分支看起来就像这样：

小结

Git分支十分强大，在团队开发中应该充分应用。

合并分支时，加上--no-ff参数就可以用普通模式合并，合并后的历史有分支，能看出来曾经做过合并，而fast forward合并就看不出来曾经做过合并

bug分支：

软件开发中，bug就像家常便饭一样。有了bug就需要修复，在Git中，由于分支是如此的强大，所以，每个bug都可以通过一个新的临时分支来修复，修复后，合并分支，然后将临时分支删除。

当你接到一个修复一个代号101的bug的任务时，很自然地，你想创建一个分支issue-101来修复它，但是，等等，当前正在dev上进行的工作还没有提交：

$ git status# On branch dev# Changes to be committed:#   (use "git reset HEAD <file>..." to unstage)##       new file:   hello.py## 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:   readme.txt#

并不是你不想提交，而是工作只进行到一半，还没法提交，预计完成还需1天时间。但是，必须在两个小时内修复该bug，怎么办？

幸好，Git还提供了一个stash功能，可以把当前工作现场“储藏”起来，等以后恢复现场后继续工作：

$ git stashSaved working directory and index state WIP on dev: 6224937 add mergeHEAD is now at 6224937 add merge

现在，用git status查看工作区，就是干净的（除非有没有被Git管理的文件），因此可以放心地创建分支来修复bug。

首先确定要在哪个分支上修复bug，假定需要在master分支上修复，就从master创建临时分支：

$ git checkout masterSwitched to branch 'master'Your branch is ahead of 'origin/master' by 6 commits.$ git checkout -b issue-101Switched to a new branch 'issue-101'

现在修复bug，需要把“Git is free software ...”改为“Git is a free software ...”，然后提交：

$ git add readme.txt $ git commit -m "fix bug 101"[issue-101 cc17032] fix bug 101 1 file changed, 1 insertion(+), 1 deletion(-)

修复完成后，切换到master分支，并完成合并，最后删除issue-101分支：

$ git checkout masterSwitched to branch 'master'Your branch is ahead of 'origin/master' by 2 commits.$ git merge --no-ff -m "merged bug fix 101" issue-101Merge made by the 'recursive' strategy. readme.txt |    2 +- 1 file changed, 1 insertion(+), 1 deletion(-)$ git branch -d issue-101Deleted branch issue-101 (was cc17032).

太棒了，原计划两个小时的bug修复只花了5分钟！现在，是时候接着回到dev分支干活了！

$ git checkout devSwitched to branch 'dev'$ git status# On branch devnothing to commit (working directory clean)

工作区是干净的，刚才的工作现场存到哪去了？用git stash list命令看看：

$ git stash liststash@{0}: WIP on dev: 6224937 add merge

工作现场还在，Git把stash内容存在某个地方了，但是需要恢复一下，有两个办法：

一是用git stash apply恢复，但是恢复后，stash内容并不删除，你需要用git stash drop来删除；

另一种方式是用git stash pop，恢复的同时把stash内容也删了：

$ git stash pop# On branch dev# Changes to be committed:#   (use "git reset HEAD <file>..." to unstage)##       new file:   hello.py## 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:   readme.txt#Dropped refs/stash@{0} (f624f8e5f082f2df2bed8a4e09c12fd2943bdd40)

再用git stash list查看，就看不到任何stash内容了：

$ git stash list

你可以多次stash，恢复的时候，先用git stash list查看，然后恢复指定的stash，用命令：

$ git stash apply stash@{0}

小结

修复bug时，我们会通过创建新的bug分支进行修复，然后合并，最后删除；

当手头工作没有完成时，先把工作现场git stash一下，然后去修复bug，修复后，再git stash pop，回到工作现场。

Feature branch：

Feature分支

软件开发中，总有无穷无尽的新的功能要不断添加进来。

添加一个新功能时，你肯定不希望因为一些实验性质的代码，把主分支搞乱了，所以，每添加一个新功能，最好新建一个feature分支，在上面开发，完成后，合并，最后，删除该feature分支。

现在，你终于接到了一个新任务：开发代号为Vulcan的新功能，该功能计划用于下一代星际飞船。

于是准备开发：

$ git checkout -b feature-vulcanSwitched to a new branch 'feature-vulcan'

5分钟后，开发完毕：

$ git add vulcan.py$ git status# On branch feature-vulcan# Changes to be committed:#   (use "git reset HEAD <file>..." to unstage)##       new file:   vulcan.py#$ git commit -m "add feature vulcan"[feature-vulcan 756d4af] add feature vulcan 1 file changed, 2 insertions(+) create mode 100644 vulcan.py

切回dev，准备合并：

$ git checkout dev

一切顺利的话，feature分支和bug分支是类似的，合并，然后删除。

但是，

就在此时，接到上级命令，因经费不足，新功能必须取消！

虽然白干了，但是这个分支还是必须就地销毁：

$ git branch -d feature-vulcanerror: The branch 'feature-vulcan' is not fully merged.If you are sure you want to delete it, run 'git branch -D feature-vulcan'.

销毁失败。Git友情提醒，feature-vulcan分支还没有被合并，如果删除，将丢失掉修改，如果要强行删除，需要使用命令git branch -D feature-vulcan。

现在我们强行删除：

$ git branch -D feature-vulcanDeleted branch feature-vulcan (was 756d4af).

终于删除成功！

多人协作：

$ git checkout -b simpledemo-ios9  origin/simpledemo-ios9

$vim test.txt

$git add test.txt

$git commit -m "add test.txt"

$git pull

$解决冲突

$git push originsimpledemo-ios9

标签管理：

• 命令git tag <name>用于新建一个标签，默认为HEAD，也可以指定一个commit id；

• git tag -a <tagname> -m "blablabla..."可以指定标签信息；

• git tag -s <tagname> -m "blablabla..."可以用PGP签名标签；

• 命令git tag可以查看所有标签。

$ git tag v0.9 6224937

$ git show v0.9

• 命令git push origin <tagname>可以推送一个本地标签；

• 命令git push origin --tags可以推送全部未推送过的本地标签；

• 命令git tag -d <tagname>可以删除一个本地标签；

• 命令git push origin :refs/tags/<tagname>可以删除一个远程标签。

自定义git：

git config --global color.ui true

忽略文件：

在Git工作区的根目录下创建一个特殊的.gitignore文件，然后把要忽略的文件名填进去，Git就会自动忽略这些文件。  模板： https://github.com/github/gitignore

最后一步就是把.gitignore也提交到Git，就完成了！当然检验.gitignore的标准是git status命令是不是说working directory clean。

• 忽略某些文件时，需要编写.gitignore；

• .gitignore文件本身要放到版本库里，并且可以对.gitignore做版本管理！

配置别名：

$ git config --global alias.st status
git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
$ git config --global alias.co checkout$ git config --global alias.ci commit$ git config --global alias.br branch

以后提交就可以简写成：

$ git ci -m "bala bala bala..."

配置Git的时候，加上--global是针对当前用户起作用的，如果不加，那只针对当前的仓库起作用。

配置文件放哪了？每个仓库的Git配置文件都放在.git/config文件中：

• 搭建Git服务器非常简单，通常10分钟即可完成；

• 要方便管理公钥，用Gitosis；

• 要像SVN那样变态地控制权限，用Gitolite。