Git & github 入门（上）

时间 2019-11-20 标签 git github 入门

本节内容html

github介绍
安装
仓库建立& 提交代码
代码回滚
工做区和暂存区
撤销修改
删除操做
远程仓库
分支管理
多人协做
github使用
忽略特殊文件.gitignore

前戏

为何要用版本控制？python

假设你在的公司要上线一个新功能，大家开发团队为实现这个新功能，写了大约5000行代码，上线没2天，就发现这个功能用户并不喜欢，你老板让你去掉这个功能，你怎么办？你说简单，直接把5000行代码去掉就好了，可是个人亲，说的简单，你的这个功能写了3周时间，但你还能记得你是新增长了哪5000行代码么？因此你急须要一个工具，能帮你记录每次对代码作了哪些修改，而且能够轻易的把代码回滚到历史上的某个状态。这个神奇的工具就叫作版本控制。 linux

版本控制工具主要实现2个功能：git

1.版本管理github

在开发中，这是刚需，必须容许能够很容易对产品的版本进行任意回滚，版本控制工具实现这个功能的原理简单来说，就是你每修改一次代码，它就帮你作一次快照vim

2.协做开发bash

一个复杂点的软件，每每不是一个开发人员能够搞定的，公司为加快产品开发速度，会招聘一堆跟你同样的开发人员开发这个产品，拿微信来举例，如今假设3我的一块儿开发微信，A开发联系人功能，B开发发文字、图片、语音通信功能，C开发视频通话功能， B和C的功能都是要基于通信录的，你说简单，直接把A开发的代码copy过来，在它的基础上开发就行了，能够，可是你在他的代码基础上开发了2周后，这期间A没闲着，对通信录代码做了更新，此时怎么办？你和他的代码不一致了，此时咱们知道，你确定要再把A的新代码拿过来替换掉你手上的旧通信录功能代码，如今人少，3我的之间沟通很简单，但想一想，若是团队变成30我的呢？来回这样copy代码，很快就乱了，因此此时亟需一个工具，能确保一直存储最新的代码库，全部人的代码应该和最新的代码库保持一致服务器

常见版本管理工具介绍微信

一、VSS-- Visual Source Safe
此工具是Microsoft提供的，是使用的至关广泛的工具之一，他能够与VS.net进行无缝集成，成为了独立开发人员和小型开发团队所适合的工具，基本上Window平台上开发的中小型企业，当规模较大后，其性能一般是没法忍受的，对分支与并行开发支持的比较有限。分布式

二、CVS--Concurrent Versions System，
此工具是一个开源工具，与后面提到的SVN是同一个厂家：Collab.Net提供的。
CVS是源于unix的版本控制工具，对于CVS的安装和使用最好对unix的系统有所了解能更容易学习，CVS的服务器管理须要进行各类命令行操做。目前，CVS的客户端有winCVS的图形化界面，服务器端也有CVSNT的版本，易用性正在提升。
此工具是至关著名，使用得至关普遍的版本控制工具之一，使用成熟的“Copy-Modify-Merge"开发模型，能够大大的提升开发效率，适合于项目比较大，产品发布频繁，分支活动频繁的中大型项目。

三、SVN --CollabNet Subversion
此工具是在CVS 的基础上，由CollabNet提供开发的，也是开源工具，目前愈来愈受到你们的欢迎，估计未来可能会成为最著名，使用最普遍的工具。
他修正cvs的一些局限性，适用范围同cvs，目前有一些基于SVN的第三方工具，如TortoiseSVN,是其客户端程序，使用的也至关普遍。在权限管理，分支合并等方面作的很出色，他能够与Apache集成在一块儿进行用户认证。
不过在权限管理方面目前尚未个很好用的界面化工具，SVNManger对于已经使用SVN进行配置的项目来讲，基本上是没法应用的，但对于从头开始的项目是能够的，功能比较强大，可是搭建svnManger比较麻烦。
是一个跨平台的软件，支持大多数常见的操做系统。做为一个开源的版本控制系统,Subversion 管理着随时间改变的数据。这些数据放置在一个中央资料档案库中。这个档案库很像一个普通的文件服务器, 不过它会记住每一次文件的变更。这样你就能够把档案恢复到旧的版本, 或是浏览文件的变更历史。Subversion 是一个通用的系统, 可用来管理任何类型的文件, 其中包括了程序源码。

4. GIT
由于最初是从Linux起家的，很是依赖文件系统的一些特性，这些在 Linux 下表现的很好，而 Windows 下特别糟糕Git 中文教程
Git是一个开源的分布式版本控制系统，用以有效、高速的处理从很小到很是大的项目版本管理.
Git 是 Linus Torvalds 为了帮助管理 Linux 内核开发而开发的一个开放源码的版本控制软件。
Torvalds 开始着手开发 Git 是为了做为一种过渡方案来替代 BitKeeper，后者以前一直是 Linux 内核开发人员在全球使用的主要源代码工具。开放源码社区中的有些人以为 BitKeeper 的许可证并不适合开放源码社区的工做，所以 Torvalds 决定着手研究许可证更为灵活的版本控制系统。尽管最初 Git 的开发是为了辅助 Linux 内核开发的过程，可是咱们已经发如今不少其余自由软件项目中也使用了 Git。例如最近就迁移到 Git 上来了，不少 Freedesktop 的项目也迁移到了 Git 上。

五、BitKeeper
是由BitMover公司提供的，BitKeeper自称是“分布式”可扩缩SCM系统。
不是采用C/S结构，而是采用P2P结构来实现的，一样支持变动任务，全部变动集的操做都是原子的，与svn,cvs一致。

1.Github介绍

1.github介绍

不少人都知道，Linus在1991年建立了开源的Linux，今后，Linux系统不断发展，已经成为最大的服务器系统软件了。

Linus虽然建立了Linux，但Linux的壮大是靠全世界热心的志愿者参与的，这么多人在世界各地为Linux编写代码，那Linux的代码是如何管理的呢？

事实是，在2002年之前，世界各地的志愿者把源代码文件经过diff的方式发给Linus，而后由Linus本人经过手工方式合并代码！

你也许会想，为何Linus不把Linux代码放到版本控制系统里呢？不是有CVS、SVN这些免费的版本控制系统吗？由于Linus坚决地反对CVS和SVN，这些集中式的版本控制系统不但速度慢，并且必须联网才能使用。有一些商用的版本控制系统，虽然比CVS、SVN好用，但那是付费的，和Linux的开源精神不符。

不过，到了2002年，Linux系统已经发展了十年了，代码库之大让Linus很难继续经过手工方式管理了，社区的弟兄们也对这种方式表达了强烈不满，因而Linus选择了一个商业的版本控制系统BitKeeper，BitKeeper的东家BitMover公司出于人道主义精神，受权Linux社区无偿使用这个版本控制系统。

安定团结的大好局面在2005年就被打破了，缘由是Linux社区牛人汇集，难免沾染了一些梁山好汉的江湖习气。开发Samba的Andrew试图破解BitKeeper的协议（这么干的其实也不仅他一个），被BitMover公司发现了（监控工做作得不错！），因而BitMover公司怒了，要收回Linux社区的无偿使用权。

Linus能够向BitMover公司道个歉，保证之后严格管教弟兄们，嗯，这是不可能的。实际状况是这样的：

Linus花了两周时间本身用C写了一个分布式版本控制系统，这就是Git！一个月以内，Linux系统的源码已经由Git管理了！牛是怎么定义的呢？你们能够体会一下。

Git迅速成为最流行的分布式版本控制系统，尤为是2008年，GitHub网站上线了（github是一个基于git的代码托管平台，付费用户能够建私人仓库，咱们通常的免费用户只能使用公共仓库，也就是代码要公开。），它为开源项目免费提供Git存储，无数开源项目开始迁移至GitHub，包括jQuery，PHP，Ruby等等。

历史就是这么偶然，若是不是当年BitMover公司威胁Linux社区，可能如今咱们就没有免费而超级好用的Git了。

 

今天，GitHub已经是：

一个拥有143万开发者的社区。其中不乏Linux发明者Torvalds这样的顶级黑客，以及Rails创始人DHH这样的年轻极客。
这个星球上最流行的开源托管服务。目前已托管431万git项目，不只愈来愈多知名开源项目迁入GitHub，好比Ruby on Rails、jQuery、Ruby、Erlang/OTP；近三年流行的开源库每每在GitHub首发，例如：BootStrap、Node.js、CoffeScript等。
alexa全球排名414的网站。

View Code

2. git安装

安装Git

最先Git是在Linux上开发的，很长一段时间内，Git也只能在Linux和Unix系统上跑。不过，慢慢地有人把它移植到了Windows上。如今，Git能够在Linux、Unix、Mac和Windows这几大平台上正常运行了。

要使用Git，第一步固然是安装Git了。根据你当前使用的平台来阅读下面的文字：

在Linux上安装Git

首先，你能够试着输入git，看看系统有没有安装Git：

$ git
The program 'git' is currently not installed. You can install it by typing:
sudo apt-get install git

像上面的命令，有不少Linux会友好地告诉你Git没有安装，还会告诉你如何安装Git。

若是你碰巧用Debian或Ubuntu Linux，经过一条sudo apt-get install git就能够直接完成Git的安装，很是简单。

3.版本库建立

什么是版本库呢？版本库又名仓库，英文名repository，你能够简单理解成一个目录，这个目录里面的全部文件均可以被Git管理起来，每一个文件的修改、删除，Git都能跟踪，以便任什么时候刻均可以追踪历史，或者在未来某个时刻能够“还原”。

因此，建立一个版本库很是简单，首先，选择一个合适的地方，建立一个空目录：

$ mkdir git_trainning
$ cd git_trainning/
 
$ git init
Initialized empty Git repository in /Users/alex/git_trainning/.git/

瞬间Git就把仓库建好了，并且告诉你是一个空的仓库（empty Git repository），细心的读者能够发现当前目录下多了一个.git的目录，这个目录是Git来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，否则改乱了，就把Git仓库给破坏了。

若是你没有看到.git目录，那是由于这个目录默认是隐藏的，用ls -ah命令就能够看见。

把文件添加到版本库

首先这里再明确一下，全部的版本控制系统，其实只能跟踪文本文件的改动，好比TXT文件，网页，全部的程序代码等等，Git也不例外。版本控制系统能够告诉你每次的改动，好比在第5行加了一个单词“Linux”，在第8行删了一个单词“Windows”。而图片、视频这些二进制文件，虽然也能由版本控制系统管理，但无法跟踪文件的变化，只能把二进制文件每次改动串起来，也就是只知道图片从100KB改为了120KB，但到底改了啥，版本控制系统不知道，也无法知道。

不幸的是，Microsoft的Word格式是二进制格式，所以，版本控制系统是无法跟踪Word文件的改动的，前面咱们举的例子只是为了演示，若是要真正使用版本控制系统，就要以纯文本方式编写文件。

由于文本是有编码的，好比中文有经常使用的GBK编码，日文有Shift_JIS编码，若是没有历史遗留问题，强烈建议使用标准的UTF-8编码，全部语言使用同一种编码，既没有冲突，又被全部平台所支持。

言归正传，如今咱们编写一个first_git_file.txt文件，内容以下：

$ vim first_git_file.txt
 
first time using git, excited!
第一次用git哈哈

必定要放到git_trainning目录下（子目录也行），由于这是一个Git仓库，放到其余地方Git再厉害也找不到这个文件。

和把大象放到冰箱须要3步相比，把一个文件放到Git仓库只须要两步。

第一步，用命令git add告诉Git，把文件添加到仓库：

 
          $ git add first_git_file.txt

执行上面的命令，没有任何显示，说明添加成功。

第二步，用命令git commit告诉Git，把文件提交到仓库：　　

$ git commit -m "commit my first git file"
 
[master (root-commit) 621e6e4] commit my first git file
 Committer: Alex Li <alex@alexs-macbook-pro.local>
Your name and email address were configured automatically based
on your username and hostname. Please check that they are accurate.
You can suppress this message by setting them explicitly. Run the
following command and follow the instructions in your editor to edit
your configuration file:
 
    git config --global --edit
 
After doing this, you may fix the identity used for this commit with:
 
    git commit --amend --reset-author
 
 1 file changed, 2 insertions(+)
 create mode 100644 first_git_file.txt
</alex@alexs-macbook-pro.local>

中间红色部分的意思是，你在往git库里提交代码时，你须要告诉git你是谁，这样git就会纪录下来是谁改的代码，其实就是为了往后查询方便，你只须要提供一个名字和邮件地址就能够，这里个人git直接经过主机名本身建立了一个，但你能够经过git config --global --edit修改

简单解释一下git commit命令，-m后面输入的是本次提交的说明，能够输入任意内容，固然最好是有意义的，这样你就能从历史记录里方便地找到改动记录。

嫌麻烦不想输入-m "xxx"行不行？确实有办法能够这么干，可是强烈不建议你这么干，由于输入说明对本身对别人阅读都很重要。

为何Git添加文件须要add，commit一共两步呢？由于commit能够一次提交不少文件，因此你能够屡次add不一样的文件，好比：

$ git add file1.txt
$ git add file2.txt file3.txt
$ git commit -m "add 3 files."

4. 代码回滚

4.1代码修改并提交　　

咱们已经成功地添加并提交了一个first_git_file.txt文件，如今，是时候继续工做了，因而，咱们继续修改first_git_file.txt文件，改为以下内容：

First time using git, excited! update ...
insert line here...
第一次用git哈哈

如今，运行git status命令看看结果：

$ git status
On branch master
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:   first_git_file.txt
 
no changes added to commit (use "git add" and/or "git commit -a")

虽然Git告诉咱们first_git_file.txt被修改了，但若是能看看具体修改了什么内容，天然是很好的。好比你休假两周从国外回来，第一天上班时，已经记不清上次怎么修改的readme.txt，因此，须要用git diff这个命令看看：

$ git diff first_git_file.txt
diff --git a/first_git_file.txt b/first_git_file.txt
index 2d13c2c..248d853 100644
--- a/first_git_file.txt
+++ b/first_git_file.txt
@@ -1,3 +1,4 @@
-first time using git, excited!
+First time using git, excited! update ...
 insert line here...
 第一次用git哈哈
+insert line again haha...

输出中＋号绿色显示的就是修改或新增的内容，－号红色显示的就是去掉或被修改的内容

知道了对first_git_file.txt 做了什么修改后，再把它提交到仓库就放心多了，提交修改和提交新文件是同样的两步，第一步是git add：

$ git add . # .  表明把当前目录下全部改动的文件都提交到代码库
Alexs-MacBook-Pro:git_trainning alex$ git commit -m "commit changes"
[master 50ad6b5] commit changes
 Committer: Alex Li <alex@Alexs-MacBook-Pro.local>
 1 file changed, 1 insertion(+)

提交后，咱们再用git status命令看看仓库的当前状态：

$ git status
# On branch master
nothing to commit (working directory clean)

Git告诉咱们当前没有须要提交的修改，并且，工做目录是干净（working directory clean）的。

4.2 代码回滚

如今，你已经学会了修改文件，而后把修改提交到Git版本库，如今，再练习一次，修改first_git_file.txtt文件以下：

First time using git, excited! update ...
insert line here..改以前的.
第一次用git哈哈
insert line again haha...
加点新内容　

而后尝试提交：


$ git add first_git_file.txt
$ git commit -m "add new content"
[master 4459657] add new content
 Committer: Alex Li <alex@Alexs-MacBook-Pro.local>
 1 file changed, 2 insertions(+), 1 deletion(-)

像这样，你不断对文件进行修改，而后不断提交修改到版本库里，就比如玩RPG游戏时，每经过一关就会自动把游戏状态存盘，若是某一关没过去，你还能够选择读取前一关的状态。有些时候，在打Boss以前，你会手动存盘，以便万一打Boss失败了，能够从最近的地方从新开始。Git也是同样，每当你以为文件修改到必定程度的时候，就能够“保存一个快照”，这个快照在Git中被称为commit。一旦你把文件改乱了，或者误删了文件，还能够从最近的一个commit恢复，而后继续工做，而不是把几个月的工做成果所有丢失。

如今，咱们回顾一下first_git_file.txt文件一共有几个版本被提交到Git仓库里了：

版本1
first time using git, excited!
第一次用git哈哈


版本2
first time using git, excited!
insert line here...
第一次用git哈哈


版本3
first time using git, excited!
insert line here...
第一次用git哈哈
insert line again haha...


版本4
First time using git, excited! update ...
insert line here..改以前的.
第一次用git哈哈
insert line again haha...
加点新内容

固然了，在实际工做中，咱们脑子里怎么可能记得一个几千行的文件每次都改了什么内容，否则要版本控制系统干什么。版本控制系统确定有某个命令能够告诉咱们历史记录，在Git中，咱们用git log命令查看：

$ git log
commit 445965781d1fd0d91e76d120450dd18fd06c7489
Author: Alex Li <alex@Alexs-MacBook-Pro.local>
Date:   Tue Oct 4 18:44:29 2016 +0800
 
    add new content
 
commit be02137bb2f54bbef0c2e99202281b3966251952
Author: Alex Li <alex@Alexs-MacBook-Pro.local>
Date:   Tue Oct 4 17:55:16 2016 +0800
 
    update again
 
commit 50ad6b526810bb7ccfea430663757ba2337b9816
Author: Alex Li <alex@Alexs-MacBook-Pro.local>
Date:   Tue Oct 4 17:46:51 2016 +0800
 
    commit changes
 
commit 621e6e44d04fa6a1cdc37826f01efa61b451abd1
Author: Alex Li <alex@Alexs-MacBook-Pro.local>
Date:   Tue Oct 4 17:42:50 2016 +0800
 
    commit my first git file

git log命令显示从最近到最远的提交日志，咱们能够看到4次提交，最近的一次是add new content，上一次是update again，最先的一次是commit my first git file。若是嫌输出信息太多，看得眼花缭乱的，能够试试加上--pretty=oneline参数：

$ git log --pretty=oneline
445965781d1fd0d91e76d120450dd18fd06c7489 add new content
be02137bb2f54bbef0c2e99202281b3966251952 update again
50ad6b526810bb7ccfea430663757ba2337b9816 commit changes
621e6e44d04fa6a1cdc37826f01efa61b451abd1 commit my first git file

须要友情提示的是，你看到的一大串相似3628164...882e1e0的是commit id（版本号），和SVN不同，Git的commit id不是1，2，3……递增的数字，而是一个SHA1计算出来的一个很是大的数字，用十六进制表示，并且你看到的commit id和个人确定不同，以你本身的为准。为何commit id须要用这么一大串数字表示呢？由于Git是分布式的版本控制系统，后面咱们还要研究多人在同一个版本库里工做，若是你们都用1，2，3……做为版本号，那确定就冲突了。

回滚回滚回滚　　

好了，如今咱们启动时光穿梭机，准备把first_git_file.txt回退到上一个版本，也就是“update again”的那个版本，怎么作呢？

首先，Git必须知道当前版本是哪一个版本，在Git中，用HEAD表示当前版本，也就是最新的提交be02137bb2f54bbef0c2e99202281b3966251952（注意个人提交ID和你的确定不同），上一个版本就是HEAD^，上上一个版本就是HEAD^^，固然往上100个版本写100个^比较容易数不过来，因此写成HEAD~100。

如今，咱们要把当前版本“add new content”回退到上一个版本“update again”，就可使用git reset命令：

$ git reset --hard HEAD^

HEAD is now at be02137 update again

此时再看你的文件内容，果真就退回去了

$ more first_git_file.txt 
   First time using git, excited! update ... 
  
   insert line here... 
  
   第一次用git哈哈 
  
   insert line again haha...

此时还能够继续再往前回退一个版本，不过且慢，然咱们用 git log再看看如今版本库的状态：

$ git log --pretty=oneline

be02137bb2f54bbef0c2e99202281b3966251952 update again

50ad6b526810bb7ccfea430663757ba2337b9816 commit changes

621e6e44d04fa6a1cdc37826f01efa61b451abd1 commit my first git file

最新的那个版本add new content已经看不到了！比如你从21世纪坐时光穿梭机来到了19世纪，想再回去已经回不去了，肿么办？

办法其实仍是有的，只要上面的命令行窗口尚未被关掉，你就能够顺着往上找啊找啊，找到那个add new content的commit id是445965781d1fd0d91e76d120450dd18fd06c7489

，因而就能够指定回到将来的某个版本：

git reset --hard 4459657

HEAD is now at 4459657 add new content

版本号不必写全，前几位就能够了，Git会自动去找。固然也不能只写前一两位，由于Git可能会找到多个版本号，就没法肯定是哪个了。

再当心翼翼地看看first_git_file.txt的内容：

First time using git, excited! update ...

insert line here..改以前的.

第一次用git哈哈

insert line again haha...

加点新内容

果真，我胡汉三又回来了。

Git的版本回退速度很是快，由于Git在内部有个指向当前版本的HEAD指针，当你回退版本的时候，Git仅仅是把HEAD从指向add new content

如今，你回退到了某个版本，关掉了电脑，次日早上就后悔了，想恢复到新版本怎么办？找不到新版本的commit id怎么办？

在Git中，老是有后悔药能够吃的。当你用$ git reset --hard HEAD^回退到update again版本时，再想恢复到最新add new content的版本，就必须找到add new contentL的commit id。Git提供了一个命令git reflog用来记录你的每一次命令：

$ git reflog

4459657 HEAD@{0}: reset: moving to 4459657

be02137 HEAD@{1}: reset: moving to HEAD^

4459657 HEAD@{2}: commit: add new content

be02137 HEAD@{3}: reset: moving to be02137bb

50ad6b5 HEAD@{4}: reset: moving to 50ad6b5

621e6e4 HEAD@{5}: reset: moving to 621e6e44

50ad6b5 HEAD@{6}: reset: moving to HEAD^

be02137 HEAD@{7}: commit: update again

50ad6b5 HEAD@{8}: commit: commit changes

621e6e4 HEAD@{9}: commit (initial): commit my first git file

终于舒了口气，第二行显示add new content的commit id是4459657，如今，你又能够乘坐时光机回到将来了。

5. 工做区和暂存区

Git和其余版本控制系统如SVN的一个不一样之处就是有暂存区的概念。

先来看名词解释。

工做区（Working Directory）

就是你在电脑里能看到的目录，好比个人git_trainning文件夹就是一个工做区：

$ ls git_trainning/
first_git_file.txt

版本库（Repository）

工做区有一个隐藏目录.git，这个不算工做区，而是Git的版本库。

Git的版本库里存了不少东西，其中最重要的就是称为stage（或者叫index）的暂存区，还有Git为咱们自动建立的第一个分支master，以及指向master的一个指针叫HEAD。

分支和HEAD的概念咱们之后再讲。

前面讲了咱们把文件往Git版本库里添加的时候，是分两步执行的：

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

第二步是用git commit提交更改，实际上就是把暂存区的全部内容提交到当前分支。

由于咱们建立Git版本库时，Git自动为咱们建立了惟一一个master分支，因此，如今，git commit就是往master分支上提交更改。

你能够简单理解为，须要提交的文件修改统统放到暂存区，而后，一次性提交暂存区的全部修改。

俗话说，实践出真知。如今，咱们再练习一遍，先对first_git_file.txt作个修改，好比加上一行内容：

　　First time using git, excited! update ...

　　insert line here..改以前的.

　　第一次用git哈哈

　　insert line again haha...

　　加点新内容

　　update v5

而后，在工做区新增一个readme.md文本文件（内容随便写）。

先用git status查看一下状态：

$ git status
On branch master
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:   first_git_file.txt
 
Untracked files:
  (use "git add <file>..." to include in what will be committed)
 
    readme.md
 
no changes added to commit (use "git add" and/or "git commit -a")

Git很是清楚地告诉咱们，first_git_file.txt被修改了，而readme.md还历来没有被添加过，因此它的状态是Untracked。

如今，使用命令git add . ，再用git status再查看一下：

$ git add .
$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
 
    modified:   first_git_file.txt
    new file:   readme.md
</file>

如今，暂存区的状态就变成这样了：

(盗图关系，这里readme.txt = first_git_file.txt , LICENSE = readme.md)

因此，git add命令实际上就是把要提交的全部修改放到暂存区（Stage），而后，执行git commit就能够一次性把暂存区的全部修改提交到分支。

$ git commit -m "知道暂存区stage的意思了"

[master 9d65cb2] 知道暂存区stage的意思了

2 files changed, 2 insertions(+)

create mode 100644 readme.md

一旦提交后，若是你又没有对工做区作任何修改，那么工做区就是“干净”的：

$ git status

On branch master

nothing to commit, working directory clean

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

(盗图关系，这里readme.txt = first_git_file.txt , LICENSE = readme.md)

暂存区是Git很是重要的概念，弄明白了暂存区，就弄明白了Git的不少操做到底干了什么。

6. 撤销修改　　

天然，你是不会犯错的。不过如今是凌晨两点，你正在赶一份工做报告，你在readme.md中添加了一行：

#git study repo

git is great

but my stupid boss still prefers SVN.

在你准备提交前，一杯咖啡起了做用，你猛然发现了“stupid boss”可能会让你丢掉这个月的奖金！

既然错误发现得很及时，就能够很容易地纠正它。你能够删掉最后一行，手动把文件恢复到上一个版本的状态。若是用git status查看一下：

git status

On branch master

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.md

no changes added to commit (use "git add" and/or "git commit -a")

</file></file>

你能够发现，Git会告诉你， git checkout -- file能够丢弃工做区的修改：

$ git checkout -- readme.md

$ more readme.md

#git study repo

你刚才添加的2行骂老板的话就被撤销了，

命令git checkout -- readme.md意思就是，把readme.md文件在工做区的修改所有撤销，这里有两种状况：

一种是readme.md自修改后尚未被放到暂存区，如今，撤销修改就回到和版本库如出一辙的状态；

一种是readme.md已经添加到暂存区后，又做了修改，如今，撤销修改就回到添加到暂存区后的状态。

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

git checkout -- file命令中的--很重要，没有--，就变成了“切换到另外一个分支”的命令，咱们在后面的分支管理中会再次遇到git checkout命令。　　

如今假定是凌晨3点，你不但写了一些胡话，还git add到暂存区了：

$ cat readme.md
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.
My stupid boss still prefers SVN.
 
$ git add readme.md

庆幸的是，在commit以前，你发现了这个问题。用git status查看一下，修改只是添加到了暂存区，尚未提交：

$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)
 
    modified:   readme.md
</file>

 Git一样告诉咱们，用命令git reset HEAD file能够把暂存区的修改撤销掉（unstage），从新放回工做区：


$ git reset HEAD readme.md
Unstaged changes after reset:
M   readme.md

git reset命令既能够回退版本，也能够把暂存区的修改回退到工做区。当咱们用HEAD时，表示最新的版本。 再用git status查看一下，如今暂存区是干净的，工做区有修改 
$ git status
# On branch master
# 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.md
#
no changes added to commit (use "git add" and/or "git commit -a")

还记得如何丢弃工做区的修改吗？ 
$ git checkout -- readme.md
 
$ more readme.md
#git study repo
整个世界终于清静了！

7. 删除操做

在Git中，删除也是一个修改操做，咱们实战一下，先添加一个新文件test.txt到Git而且提交：　　

$ git add .
$ git commit -m "add test.txt"
[master a8fa95a] add test.txt
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 test.txt

通常状况下，你一般直接在文件管理器中把没用的文件删了，或者用rm命令删了:$ rm test.txt

这个时候，Git知道你删除了文件，所以，工做区和版本库就不一致了，git status命令会马上告诉你哪些文件被删除了：

$ git status
On branch master
Changes not staged for commit:
  (use "git add/rm <file>..." to update what will be committed)
  (use "git checkout -- <file>..." to discard changes in working directory)
 
    deleted:    test.txt
 
no changes added to commit (use "git add" and/or "git commit -a")

如今你有两个选择，一是确实要从版本库中删除该文件，那就用命令git rm删掉，而且git commit：

x$ git rm test.txt
rm 'test.txt'
 
$ git commit -m "remove test"
[master 03df00a] remove test
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 test.txt

如今，文件就从版本库中被删除了。

另外一种状况是删错了，由于版本库里还有呢，因此能够很轻松地把误删的文件恢复到最新版本：$ git checkout -- test.txt

git checkout实际上是用版本库里的版本替换工做区的版本，不管工做区是修改仍是删除，均可以“一键还原”。

文章太长为了方便阅读请看：

git &github 快速入门（下）