git初级使用教程

原文：http://blog.csdn.net/u014079773/article/details/49555989

 

 

对于初学者，首先要了解什么是Git；为什么使用git；如何使用git；如git初始化配置，把本地项目提交到远程github上。

官网下载git：https://git-scm.com/download/

一：git初始配置

空白处或者指定目录下右击“Git Bash Here”

在命令行输入如下信息：
$ git config --global user.name “You Name”                       用户名
$ git config --global user.email "email@example.com"   邮箱地址

因为git是分布式版本控制系统，所以需要填写用户名和邮箱作为一个标识。注意git config --global 参数，有了这个参数，表示你这台机器上所有的git仓库都会使用这个配置，当然你也可以对某个仓库指定不同的用户名和邮箱。

查看git初始化配置：$ git config --list

备注：第一次使用git时必须有git账号，因此首先需注册git账号，注册账号可以用命令行如上诉操作，也可以直接登录github官网注册。

二：创建仓库

版本库：又名仓库，英文名repository，可以理解成一个目录，这个目录里面的所有文件都可以被git管理起来，每个文件的修改，删除git都跟踪，以便任何时刻都可以追踪历史或者在将来某个时刻还可以将文件”还原“。

如在我本地windows环境下创建自己的仓库

$ mkdir learnGit

$ cd learnGit

$pwd

pwd命令用于显示当前目录。

注意：在windows系统，为了避免遇到各种莫名其妙的问题，请确保目录名（包括父目录）不含中文。

通过git init 命令把这个目录变成git可以管理的仓库。

$ git init

这样仓库就创建好了，而且告诉你是一个空的仓库（empty Git repository）可以发现当前目录下多了一个".git"目录，这个目录是 git来跟踪管理版本库的，不能手动修改这个目录里面的文件，否则会把git仓库破坏了。如果你没有看到".git"目录，是因为目录默认是隐藏的，用ls -ah命令可以查看。

在创建的目录learngit会看到一个隐藏文件夹”.git“

注意默认情况下是不显示的，若是你想看到隐藏的文件夹则”工具“--”文件夹选项“--”查看“--”显示隐藏的文件，文件夹或驱动器“

把文件添加到版本库

首先要明确下，所有的版本控制系统，只能跟踪文本文件的改动，比如txt文件，网页，所有程序的代码等，Git也不列外，版本控制系统可以告诉你每次的改动，但是图片，视频这些二进制文件，虽能也能由版本控制系统管理，但没法跟踪文件的变化，只能把二进制文件每次改动串起来，也就是知道图片从1kb变成2kb，但是到底改了啥，版本控制也不知道。不幸的是，Microsoft的Word格式是二进制格式，因此，版本控制系统是没法跟踪Word文件的改动的，前面我们举的例子只是为了演示，如果要真正使用版本控制系统，就要以纯文本方式编写文件。因为文本是有编码的，比如中文有常用的GBK编码，日文有Shift_JIS编码，如果没有历史遗留问题，强烈建议使用标准的UTF-8编码，所有语言使用同一种编码，既没有冲突，又被所有平台所支持。

注意：千万不要使用Windows自带的记事本编辑任何文本文件。原因是Microsoft开发记事本的团队使用了一个非常弱智的行为来保存UTF-8编码的文件，他们自作聪明地在每个文件开头添加了0xefbbbf（十六进制）的字符，你会遇到很多不可思议的问题，比如，网页第一行可能会显示一个“?”，明明正确的程序一编译就报语法错误，等等，都是由记事本的弱智行为带来的。建议你下载Notepad++或者editplus代替记事本，不但功能强大，而且免费！记得把Notepad++或editplus的默认编码设置为UTF-8 即可。

在新创建的仓库”learngit“下创建文件”learngit.txt“,然后用文本编辑器editplus编写一个learngit.txt内容如下：

Git is a version control system.

Git is free software.
注意：新创建的文件”learngit.txt“一定要放在learngit目录下（子目录也行）因为这是一个git仓库，放在其他地方git找不到这个文件。

用git add 告诉git，把文件添加到仓库

$ git add learngit.txt

用git commit告诉git，把文件提交到仓库。

$ git commit -m "write a learnGit file"

注意：-m后面输入的是本次提交说明，可以输入任何内容，最好输入有意义的，做到见名思义，这样你就能从历史记录里方便找到改动记录。若是嫌弃麻烦不想写，可以，但是作为一名开发人员，跟写注释一样，方便他人，增强代码阅读性。

git commit命令执行成功后会告诉你，一个文件被改动了（添加的learnGit.txt）插入了两行内容（learnGit.txt有两行内容）。

为什么git添加文件需要add，commit一共两步呢？因为commit可以一次提交很多文件，所以可以多次add不同文件，如：

$git add file1.txt

$git add file2.txt file3.txt

$ git commmit -m "add three files"

注意提交文件一定要进行如上两步git add git commit 否则提交不成功。原因下面会讲到。

三：版本回退

成功添加并提交一个learngit.txt文件后，继续修改learnit.txt文件，如下内容：

Git is a distributed version control system.

Git is fress software.

运行git status命令查看结果：

$ git status

git status命令可以让我们掌握仓库当前的状态，上面的命令告诉我们，该文件被修改过了，但还没有准备提交的修改。

虽然git告诉我们该文件被修改了，但如果能看看具体修改了什么内容，自然是好的。比如你过段时间再次查看该文件，已经记不清上次怎么修改learngit.txt，所以用git diff 命令查看。

$ git diff learngit.txt

git diff顾名思义就是查看difference，显示的格式正式Unix通用的diff格式，可以从上面的命令输出看到，我们在第一行添加了一个”distributed“单词。知道了对learngit.txt做了什么修改后，再把它提交到仓库。提交修改和提交新文件是一样两步。

$ git add learngit.txt

同样没有任何输出（说明操作正确）在执行第二步git commit之前，我们再运行git status看看当前仓库状态：

$ git status

git status命令告诉我们，将要被提交的修改包括learngit.txt这下就可以放心提交了。

$ git commit -m "add distributed"

提交后，我们再用git status命令查看仓库当前状态

$ git status

git 告诉我们当前没有需要提交的修改，而且工作目录是干净（working directory clean）的。

接下来我们继续对文件修改，提交。

Git is a distributed version control system.

Git is free software distributed under the GPL.

然后提交：


$ git add learngit.txt


$ git commit -m "append GPL"




现在回顾下learnGit.txt一共有几个版本提交到git仓库：

版本一：write a learnGit file

Git is a version control system.

Git is free software.

版本二：add distributed

Git is a distributed version control system.

Git is free software.

版本三：append GPL

Git is a distributed version control system.

Git is free software distributed under the GPL.

当前，在实际开发中，我们会修改很多内容，肯定记不住那么多内容。故我们用git log 命令查看。

$ git log 





git log命令显示从最近到最远的提交日志。若是嫌弃输出信息太多，可以加“--pretty=oneline”参数：

$ git log --pretty=oneline




需要友情提示的是，你看大的一大串类似”a9615...46c0“的是commit id（版本号），和svn不一样，git的commit id 不是1，2,3.....递增的数字，而是 一个SHA1计算出来的一个非常大的数字，用十六进制表示，而且你看到的commit id和我肯定的不一样，以自己的为准。为什么commit id需要用那么一大串数字表示呢？因为git是分布式版本控制系统。

现在我们想要git回退到我们想要的版本中，则git必须知道当前版本是哪个版本，在git中用“HEAD”表示当前版本，上一个版本“HEAD^”当然往上100个版本写100个“^”比较容易写不出来，所以写成HEAD~100

现在，我们要把当前版本“append GPL”回退到上一个版本“add distributed”可以用git reset命令：

$ git reset --hard HEAD^

查看learngit.txt的内容是不是版本”add distributed“

$ cat learngit.txt




用git log再看看现在版本库的状态

$ git log




可以发现最新的那个版本append GPL 已经看不到了。要想回退到这个版本，只要你上面的命令没有关闭，找到那个append GPL 的commit id 是"a9615a8",于是就可以指定回到某个版本：

$ git reset --hard a9615a8




版本号没必要写全，前几位就可以git会自动去找。

再次查看learngit.txt内容

$ cat learngit.txt




果然，版本正常回退到你想要的版本中。

现在你回退到你想要的版本中，但是你关闭命令窗口或者关闭电脑怎么办呢？git提供了一个命令git reflog 用来记录你的每一次命令：

$ git reflog




在该命令中你会看到不同版本都会有指定的commit id 。这样你就可以回退到你想要的版本中了。

四:工作区和暂存区

git和其他版本控制系统如svn的一个不同之处就是有暂存区的概念。

工作区（working directory）：就是在电脑能看到的目录，如我的learngit文件夹就是一个工作区。

版本库（repository）：工作区有一个隐藏的目录“.git”就是git的版本库。

git的版本库里存了很多东西，其中最主要的就是称为stage的暂存区，还有git自动为我们创建的第一个分支master以及指向master的一个指针HEAD

我们把文件往git版本添加的时候是分两步执行的。

第一步git add 把文件添加进去，实际上就是把文件修改添加到暂存区的；

第二步git commit 提交修改，实际上就是把暂存区的所有内容提交到当前分支。

因为我们创建git版本库时，git自动为我们创建唯一一个master分支，所以现在git commit 就是往master分支上提交更改。通俗点讲需要提交的文件修改通通放到暂存区，一次性提交暂存区的所有修改。

如下操作：先对learngit.txt做个修改：

Git is a distributed version control system.

Git is free software distributed under the GPL

Git has a mutable index called stage.

然后在工作区新增一个“license”文件（内容随便写点什么）

用git status 查看一下状态：

$ git status

git 非常清楚的告诉我们，learngit.txt被修改了，而license还未被添加过，所以它的状态为“untracked”。

现在使用两次命令git add 把learngit.txt license 都添加后用git status再查看下：

现在暂存区的状态就变成了这样：

所以git add 命令实际上就是把要提交的所有修改放到暂存区（stage），然后执行git commit就可以一次性把暂存区的所有修改提交到分支。

$ git commit -m "understand how stage work"

一旦提交后，如果你又没有对工作区做任何修改，那么工作区就是干净的。

$ git status

现在版本库就变成了这样，暂存区就没有任何内容了：

这就是为什么提交文件必须执行 git add git commit 两步，否则提交不成功。

五：撤销和删除文件

git跟踪并管理的是修改而非文件。什么是修改，就是你删除一行，增加一行，新增一个文件等操作。为什么git管理是修改而不是文件呢?请看如下操作：

$ cat learngit.txt

Git is a distributed version control system.

Git is a free software distributed under the GPL.

Git has a mutable index called stage.

Git tracks changes.

My stupid boss still prefers SVN.

用git status查看下：

$ git status

git告诉你，git checkout --file 可以丢弃工作区的修改：

$git checkout --learngit.txt

git checkout --learngit.txt意思就是把learn.git文件在工作区的修改全部撤销。有两种情况：

一种是learngit.txt自修改后还没有被放到暂存区，现在撤销修改就回到和版本一模一样的状态。

一种是learngit.txt已经添加到暂存区后又做了修改，现在撤销修改就回到添加到暂存区后的状态。

总之就是让这个文件回到最近一次git commit 或git add 时的状态。

查看learngit.txt文件内容：

$ cat learngit.txt

发现撤销到 git add时的状态。

注意：git checkout --file 命令中“--”很重要，没有“--”就变成了“切换到另外一个分支的命令”。

再次修改learngit.txt然后git status查看状态然后如下操作：

git告诉我们，命令git reset HEAD file 可以把暂存区的修改撤销，重新放回工作区：


$ git reset HEAD learngit.txt




git reset  既可以回退版本也可以把暂存区的修改撤销掉，重新放回工作区。当我们用HEAD时，表示最新的版本。

再用git status查看下，现在暂存区是干净的，工作区有修改:




$ git rm license.txt

$ git commit -m "remove license.txt"




git rm file 把文件从版本库中删除。如果一个文件已经被提交到版本库，那么你永远不用担心误删，但是要小心，你只能恢复到最新版本，你会丢失最近一次提交后你修改的内容。

若是你无意中删除你不想删除的文件，可以把删除的恢复。

$ git checkout --lincese.txt

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

注意：撤销删除操作，必须是未git commit之前，若是你已经git commit那么该操作无法实现


六：添加远程仓库


请在github官网注册注册自己的github账号，官网地址：https://github.com/      由于本地的git仓库和github仓库之间的传输是通过SSH加密的，所以需要一些设置：

第一步：创建SSH key。在用户主目录下，看看有没有.ssh目录，如果有，再看看这个目录下有没有id_rsa和id_rsa.pub这个两个文件，如果没有则进行如下命令：

$ ssh-keygen -t rsa -C "youemail@example.com"

把邮箱地址换成自己的邮箱地址，一路回车，使用默认值即可，由于这个key不用什么大用处，所以不需要设置密码，个人喜好。

表示生成的SSH key成功。id_rsa是私钥，不能泄露出去，id_rsa.pub是公钥，可以告诉别人。

第二步：登录github，打开”Account settings“ "SSH Keys"页面，然后点”Add SSH Key“ 填上任意title，在key的文本框粘贴”id_rsa.pub“文件的内容：

点”Add key“，就可以看到已将添加的key。

注意：为什么github需要SSH Key呢？因为github需要识别出你推送的提交确实是你推送的，而不是被人推送的，而git支持SSH协议，所以github只要知道了你的公钥，就可以确认只有你才可以推送。当然github允许添加多个key。如果你在本地电脑操作，又在公司电脑操作，只要把每台点脑的key都添加到github，这样就可以在每台电脑上往github推送了。

现在的情景是，你已经在本地创建了一个Git仓库后，又想在GitHub创建一个Git仓库，并且让这两个仓库进行远程同步，这样，GitHub上的仓库既可以作为备份，又可以让其他人通过该仓库来协作，真是一举多得。

首先，登陆GitHub，然后，在右上角找到“Create a new repo”按钮，创建一个新的仓库：

目前在github上的这个”learngit“仓库是空的，github告诉我们，可以从这个仓库克隆出新的仓库，也可以把一个已有的本地仓库与之关联，然后把本地仓库的内容推送到github仓库。

现在，我们根据github的提示，在本地的”learngit“仓库下运行命令：

$ git remote add origin git@github.com:love-sang/learngit.git

 

请千万注意，把上面的love-sang替换成你自己的GitHub账户名。添加后，远程库的名字就是origin，这是Git默认的叫法也可以改成别的，但是origin这个名字一看就知道是远程库。下一步，就可以把本地库的所有内容推送到远程库上：

$ git push -u origin master

 

把本地库的内容推送到远程，用git push命令，实际上是把当前分支master推送到远程。

由于远程库是空的，我们第一次推送master分支时，加上了-u参数，Git不但会把本地的master分支内容推送的远程新的master分支，还会把本地的master分支和远程的master分支关联起来，在以后的推送或者拉取时就可以简化命令。

推送成功后，可以立刻在GitHub页面中看到远程库的内容已经和本地一模一样，如下截图表示上传成功。

 

从现在起，只要本地作了提交，就可以通过命令：

$ git push origin master

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

注意：SSH警告

当你第一次使用Git的clone或者push命令连接GitHub时，会得到一个警告：

这是因为Git使用SSH连接，而SSH连接在第一次验证GitHub服务器的Key时，需要你确认GitHub的Key的指纹信息是否真的来自GitHub的服务器，输入yes回车即可。

Git会输出一个警告，告诉你已经把GitHub的Key添加到本机的一个信任列表里了：

总结：要关联一个远程库，使用命令git remote add origin git@server-name:path/repo-name.git；

关联后，使用命令git push -u origin master第一次推送master分支的所有内容；

此后，每次本地提交后，只要有必要，就可以使用命令git push origin master推送最新修改；

 

分布式版本系统的最大好处之一是在本地工作完全不需要考虑远程库的存在，也就是有没有联网都可以正常工作，而SVN在没有联网的时候是拒绝干活的！当有网络的时候，再把本地提交推送一下就完成了同步，真是太方便了！

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

使用https除了速度慢以外，还有个最大的麻烦是每次推送都必须输入口令，但是在某些只开放http端口的公司内部就无法使用ssh协议而只能用https。但通过ssh支持的原生git协议速度最快。

注意：本地创建的库如”learngit“ 而github上创建的库”learngit“必须同名，否则会找不到对应的库。

当然你也可以在github上创建一个仓库然后克隆到本地。如下操作：

$ git clone git@github.com:xxx/xxx.git


七：创建与合并分支

我们知道每次提交，Git都把它们串成一条时间线，这条时间线就是一个分支。截止到目前，只有一条时间线，在Git里，这个分支叫主分支，即master分支。HEAD严格来说不是指向提交，而是指向master，master才是指向提交的，所以，HEAD指向的就是当前分支。

一开始的时候，master分支是一条线，Git用master指向最新的提交，再用HEAD指向master，就能确定当前分支，以及当前分支的提交点：

每次提交，master分支都会向前移动一步，这样，随着你不断提交，master分支的线也越来越长：

当我们创建新的分支，例如dev时，Git新建了一个指针叫dev，指向master相同的提交，再把HEAD指向dev，就表示当前分支在dev上：

 

你看，Git创建一个分支很快，因为除了增加一个dev指针，改改HEAD的指向，工作区的文件都没有任何变化！

不过，从现在开始，对工作区的修改和提交就是针对dev分支了，比如新提交一次后，dev指针往前移动一步，而master指针不变：

假如我们在dev上的工作完成了，就可以把dev合并到master上。Git怎么合并呢？最简单的方法，就是直接把master指向dev的当前提交，就完成了合并：

所以Git合并分支也很快！就改改指针，工作区内容也不变！

合并完分支后，甚至可以删除dev分支。删除dev分支就是把dev指针给删掉，删掉后，我们就剩下了一条master分支：

首先，创建dev分支，然后切换到dev分支:

$ git checkout -b dev




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

$ git branch dev      --创建分支


$ git checkout dev   --切换分支


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

$ git branch

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

现在我们可以在”dev“分支上正常提交。如对learngit.txt做个修改：

Creating a new branch is quick.

然后提交：

$git add learngit.git

$ git commit -m "branch test"

现在由dev分支切换到master分支上

$ git checkout master

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

现在我们把dev分支的工作合并到master分支上：

$ git merge dev

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

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

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

$ git branch -d dev

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

$ git branch

因为创建，合并和删除分支非常快，所以git鼓励我们使用分支完成某个任务，合并后删除分支，这跟在master上工作一样，但是更安全。


在日常开发中我们提交代码会经常遇到多个人同时修改一个文件，遇到冲突，那么如何解决冲突呢？

首先我们创建并切换到冲突分支feature1

$ git checkout -b feature1

修改learngit.txt最后一行，改为:

Creating a new branch is quick and simple.

在feature1分支上提交：

$ git add learngit.txt

$ git commit -m "and simple."

切换主分支master

$ git checkout master

在master分支上把learngit.txt的最后一行修改为：

Creating a new branch is quick & simple.

提交：

$ git add learngit.txt

$ git commit -m "& simple."

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

这种情况下，git无法执行”快速合并“，只能把各自的修改合并起来，故这种合并就可能会有冲突：

$ git merge feature1

git告诉我们，learngit.txt文件存在冲突，必须手动解决冲突再提交，git status可以查看冲突文件：

$ git status

查看learngit.txt的内容，知道冲突地方：

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

Creating a new branch is quick and simple.

现在master分支和feature1分支变成了如下截图：

手动修改冲突文件learngit.txt然后提交，然后合并分支，最后删除feature1分支：

$ git merge feature1

$ git branch -d feature1

 

通常合并分支时Git默认使用Fast forward模式，但这种模式下，删除分支后会丢掉分支信息。如果要强制禁用Fast forward模式，Git就会在merge时生成一个新commit，这样，从分支历史上就可以看出分支信息。

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


$ git merge --no-ff -m "merge with no-ff" feature1

"-m"参数，把commit描述写进去。

$ git log --graph

可以查看到分支具体情况。

有时在开发过程中你创建了一个分支feature-vulcan，但是没有和master分支合并，而你就想删除feature-vulcan分支：

删除失败，git告诉你，feature-vulcan分支还没有被合并，如果删除，将丢失掉修改，如果强制性删除，用命令：git branch -D feature1

$ git branch -D feature1

git branch -D <name>表示：丢弃一个没有被合并过的分支，强行删除。

八：多人协作开发

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

首先我们把正在工作的dev分支“储存起来”：

$ git stash

git stash 命令就是把当前修改还未commit先”储存起来“.

修改bug，首先要确定在哪个分支上修改bug，然后切换到该分支上，然后创建bug分支,如在master分支上修改bug：

$ git checkout master

$ git checkout -b issue-101

修改bug完成后提交(随便在learngit.txt上写点什么)

$ git add learngit.txt

$ git commit -m "fix bug 101"

修改完成后，切换到master分支，并合并分支，最后删除bug分支

$ git checkout master

$ git merge --no-ff -m "merge bug fix 101" issue-101

$ git branch -d issue-101

到处我们修改完bug并提交，之前我们把正在工作的dev分支还原：

切换到dev分支

$ git checkout dev

$ git status

用git stash list查看被“储存起来”的dev分支

$ git stash list

恢复dev分支有2中方法：一种是git stash apply 但是恢复后stash内容并不删除，需要用 git stash drop来删除；另一种是git stash pop恢复的同时也把stash内容删除：

git stash pop

再用git stash list 查看，stash没有任何内容。

在日常开发中我们需要把远程github仓库下载到本地进行开发，故我们需要克隆远程仓库，实际上git自动把本地的master分支和远程的分支对应起来，并且远程仓库的默认名称是origin

查看远程仓库用 git remote

$ git remote

用git remote -v显示详细信息

$ git remote -v

把本地所有提交到远程仓库，提交要指定本地分支，这样git就会把该分支推送到远程仓库对应分支上：

$ git push origin master

若是推送其他分支如dev分支则：

$ git push origin dev

注意：推送分支不是什么都推送有些不需要。首先master分支是主分支，本地和远程时刻保持同步。其次dev分支是开发分支，所有人都在上面开发，所以也要时刻保持同步，再次bug分支只用于本地修改bug，就不需要推送到远程，最后其他自己测试分支feature也不需要推送到远程。

克隆远程仓库：

git clone git@github.com:love-sang/learngit.git

注意默认情况下远程clone是master分支。

日常开发中我们不在master上工作，都是创建dev分支进行协作开发然后推动到远程仓库中：

首先创建远程origin的dev分支到本地：

$ git checkout -b dev origin/dev

然后修改dev分支上的内容，再把dev分支push到远程(learngit.txt上随便写点什么)

$ git add learngit.txt

$ git commit -m "write learngit file"

$ git push origin dev

若是在推送过程中发生冲突，则我们先git pull 把最新的提交从origin/dev上抓下来，然后在本地合并解决冲突再推送：

$ git pull

这是发现git pull也失败是因为没有指定本地dev分支与远程origin/dev分支的链接，则先设置本地和远程dev链接：

git branch --set-upstream dev origin/dev

然后再git pull

$ git pull

注意：在远程git pull 的dev分支时出现“no tracking information”则说明本地分支和远程分支的链接没有仓库，

用命令：git branch --set-upstream branch-name origin/branch-name