准备工作

git简介：

Git是目前世界上最先进的分布式版本控制系统（没有之一,如果不认可，那就最流行的）。

git应用

多个人同时协作一个项目，有可能出现两个人同时修改一个文件，这时后提交的人会遇到冲突，需要解决冲突；git能够记录每个人的提交修改等形成日志，可以根据提交记录进行回滚；并且git支持分布式部署。

git诞生

本着实用主义（虽然感觉忘本，emmm）,不说啦！

版本控制系统：集中式vs分布式

集中式

先说集中式版本控制系统(代表：CVS及SVN)，版本库是集中存放在中央服务器的，而干活的时候，用的都是自己的电脑，所以要先从中央服务器取得最新的版本，然后开始干活，干完活了，再把自己的活推送给中央服务器。中央服务器就好比是一个图书馆，你要改一本书，必须先从图书馆借出来，然后回到家自己改，改完了，再放回图书馆。

集中式

集中式版本控制系统最大的毛病就是必须联网才能工作，如果在局域网内还好，带宽够大，速度够快，可如果在互联网上，遇到网速慢的话，可能提交一个10M的文件就需要5分钟，这......哎.....
分布式
分布式版本控制系统（代表：git）与集中式版本控制系统有何不同呢？首先，分布式版本控制系统根本没有“中央服务器”，每个人的电脑上都是一个完整的版本库，这样，你工作的时候，就不需要联网了，因为版本库就在你自己的电脑上。既然每个人电脑上都有一个完整的版本库，那多个人如何协作呢？比方说你在自己电脑上改了文件A，你的同事也在他的电脑上改了文件A，这时，你们俩之间只需把各自的修改推送给对方，就可以互相看到对方的修改了。
和集中式版本控制系统相比，分布式版本控制系统的安全性要高很多，因为每个人电脑里都有完整的版本库，某一个人的电脑坏掉了不要紧，随便从其他人那里复制一个就可以了。而集中式版本控制系统的中央服务器要是出了问题，所有人都没法干活了。

在实际使用分布式版本控制系统的时候，其实很少在两人之间的电脑上推送版本库的修改，因为可能你们俩不在一个局域网内，两台电脑互相访问不了，也可能今天你的同事病了，他的电脑压根没有开机。因此，分布式版本控制系统通常也有一台充当“中央服务器”的电脑，但这个服务器的作用仅仅是用来方便“交换”大家的修改，没有它大家也一样干活，只是交换修改不方便而已。

分布式

git安装

请参考https://www.liaoxuefeng.com/wiki/0013739516305929606dd18361248578c67b8067c8c017b000/00137396287703354d8c6c01c904c7d9ff056ae23da865a000

进入正题

创建版本库

#第一步
mkdir learn_git
cd learn_git
pwd
#第二步：通过git init命令把这个目录变成Git可以管理的仓库
git init

git init

首先，选择一个合适的地方，创建一个空目录
通过git init命令把这个目录变成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编码，所有语言使用同一种编码，既没有冲突，又被所有平台所支持。

添加文件到git仓库

现在我们编写一个readme.txt文件，内容如下：

Git is a version control system.
Git is free software.

一定要放到learn_git目录下（子目录也行），因为这是一个Git仓库，放到其他地方Git再厉害也找不到这个文件。
和把大象放到冰箱需要3步相比，把一个文件放到Git仓库只需要两步。

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

git add readme.txt

执行上面的命令，没有任何显示，这就说明成功添加readme.txt到仓库啦！

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

git commit -m "wrote a readme file"

git add&commit

解释
git commit命令，-m后面输入的是本次提交的说明，可以输入任意内容，当然最好是有意义的，这样你就能从历史记录里方便地找到改动记录。
嫌麻烦不想输入-m "xxx"行不行？确实有办法可以这么干，但是强烈不建议你这么干，因为输入说明对自己对别人阅读都很重要。实在不想输入说明的童鞋请自行Google，先这个参数。
git commit命令执行成功后会告诉你，1 file changed：1个文件被改动（我们新添加的readme.txt文件）；2 insertions：插入了两行内容（readme.txt有两行内容）。
为什么Git添加文件需要add，commit一共两步呢？因为commit可以一次提交很多文件，所以你可以多次add不同的文件，比如：

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

总结之添加文件到git仓库：
添加文件到Git仓库，分两步：
1-使用命令git add ，注意，可反复多次使用，添加多个文件；
2-使用命令git commit -m ，完成。

git 工作流程

继续下一步之前，先来看看git 工作流程

git 工作流

git 工作流

git 命令与流程的对应

Workspace：工作区
Index / Stage：暂存区
Repository：仓库区（或本地仓库）
Remote：远程仓库

git status & git diff

掌握工作区的状态，使用git status命令;如果git status告诉你有文件被修改过，用git diff可以查看修改内容。
继续修改readme.txt文件，改成如下内容:

Git is a distributed version control system.
Git is free software.

结果如下：

EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git checkout -- ..." to discard changes in working directory)

    modified:   readme.txt

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

git status命令可以让我们时刻掌握仓库当前的状态，上面的命令输出告诉我们，readme.txt被修改过了，但还没有准备提交的修改。
虽然Git告诉我们readme.txt被修改了，但如果能看看具体修改了什么内容，自然是很好的。比如你休假两周从国外回来，第一天上班时，已经记不清上次怎么修改的readme.txt，所以，需要用git diff这个命令看看：

git diff

结果：

EBJ1263:learn_git tao2.zhang$ git diff
diff --git a/readme.txt b/readme.txt
index 46d49bf..9247db6 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,2 +1,2 @@
-Git is a version control system.
+Git is a distributed version control system.
 Git is free software.

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

git add readme.txt

具体操作命令以及命令结果如下：

EBJ1263:learn_git tao2.zhang$ git add readme.txt 
EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD ..." to unstage)

    modified:   readme.txt

EBJ1263:learn_git tao2.zhang$ git commit -m "add distributed"
[master 1d8e5ba] add distributed
 1 file changed, 1 insertion(+), 1 deletion(-)
EBJ1263:learn_git tao2.zhang$ git status
On branch master
nothing to commit, working tree clean

总结：

要随时掌握工作区的状态，使用git status命令。
如果git status告诉你有文件被修改过，用git diff可以查看修改内容。

版本回退

可以继续对read.txt修改提交，练习一下。

Git is a distributed version control system.
Git is free software distributed under the GPL.

结果：

EBJ1263:learn_git tao2.zhang$ vim readme.txt 
EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git checkout -- ..." to discard changes in working directory)

    modified:   readme.txt

no changes added to commit (use "git add" and/or "git commit -a")
EBJ1263:learn_git tao2.zhang$ git diff
diff --git a/readme.txt b/readme.txt
index 9247db6..8443d23 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,2 +1,2 @@
 Git is a distributed version control system.
-Git is free software.
+Git is free software distributed under the GPL.
EBJ1263:learn_git tao2.zhang$ git add readme.txt 
EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD ..." to unstage)

    modified:   readme.txt

EBJ1263:learn_git tao2.zhang$ git diff
EBJ1263:learn_git tao2.zhang$ git commit -m "append GPL"
[master bf93d54] append GPL
 1 file changed, 1 insertion(+), 1 deletion(-)
EBJ1263:learn_git tao2.zhang$ git status
On branch master
nothing to commit, working tree clean

截止目前，已经有三个版本提交到git仓库啦，分别是：
version-1：wrote a readme file
version-2：add distributed
version-3：append GPL
git log命令显示从最近到最远的提交日志，我们可以看到3次提交，最近的一次是append GPL，上一次是add distributed，最早的一次是wrote a readme file。

EBJ1263:learn_git tao2.zhang$ git log
commit bf93d546ed6573c5742d34135e99f44e57d748bd (HEAD -> master)
Author: CarlBebetter <[email protected]>
Date:   Sun Apr 7 15:24:39 2019 +0800

    append GPL

commit 1d8e5ba3ffc284075f67e0fc57ef0af4d8922479
Author: CarlBebetter <[email protected]>
Date:   Sun Apr 7 15:18:21 2019 +0800

    add distributed

commit 1a6f842feeb3f991d1df792e808a25fe6e7aeb5a
Author: CarlBebetter <[email protected]>
Date:   Sat Apr 6 09:15:44 2019 +0800

    wrote a readme file

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

EBJ1263:learn_git tao2.zhang$ git log --pretty=oneline
bf93d546ed6573c5742d34135e99f44e57d748bd (HEAD -> master) append GPL
1d8e5ba3ffc284075f67e0fc57ef0af4d8922479 add distributed
1a6f842feeb3f991d1df792e808a25fe6e7aeb5a wrote a readme file

注：类似1d8e5ba3ffc284075f67e0fc57ef0af4d8922479的是commit id（版本号）

现在我们进入版本回退，准备把readme.txt回退到上一个版本，也就是add distributed的那个版本，怎么做呢？
首先，Git必须知道当前版本是哪个版本，在Git中，用HEAD表示当前版本，也就是最新的提交 bf93d546ed6573c5742d34135e99f44e57d748bd （注意我的提交ID和你的肯定不一样），上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本写100个^比较容易数不过来，所以写成HEAD~100。
现在，我们要把当前版本append GPL回退到上一个版本add distributed，就可以使用git reset命令并查看read.txt中内容：

EBJ1263:learn_git tao2.zhang$ git reset --hard HEAD^
HEAD is now at 1d8e5ba add distributed
EBJ1263:learn_git tao2.zhang$ cat readme.txt 
Git is a distributed version control system.
Git is free software.

果然被还原了。
还可以继续回退到上一个版本wrote a readme file，不过，我们用git log再看看现在版本库的状态：

EBJ1263:learn_git tao2.zhang$ git log
commit 1d8e5ba3ffc284075f67e0fc57ef0af4d8922479 (HEAD -> master)
Author: CarlBebetter <[email protected]>
Date:   Sun Apr 7 15:18:21 2019 +0800

    add distributed

commit 1a6f842feeb3f991d1df792e808a25fe6e7aeb5a
Author: CarlBebetter <[email protected]>
Date:   Sat Apr 6 09:15:44 2019 +0800

    wrote a readme file

最新的那个版本append GPL已经看不到了！好比你从21世纪坐时光穿梭机来到了19世纪，想再回去已经回不去了，肿么办？
办法其实还是有的，只要上面的命令行窗口还没有被关掉，你就可以顺着往上找啊找啊，找到那个append GPL的commit id是bf93d546ed6573c5742d34135e99f44e57d748bd ，于是就可以指定回到未来的某个版本(git reset --hard bf93d546)：

EBJ1263:learn_git tao2.zhang$ git reset --hard bf93d5
HEAD is now at bf93d54 append GPL
EBJ1263:learn_git tao2.zhang$ cat readme.txt 
Git is a distributed version control system.
Git is free software distributed under the GPL.

Git的版本回退速度非常快，因为Git在内部有个指向当前版本的HEAD指针，当你回退版本的时候，Git仅仅是把HEAD从指向append GPL：

git-head

改为指向add distributed：

git-head-move

然后顺便把工作区的文件更新了。所以你让HEAD指向哪个版本号，你就把当前版本定位在哪。
现在，你回退到了某个版本，关掉了电脑，第二天早上就后悔了，想恢复到新版本怎么办？找不到新版本的commit id怎么办？
在Git中，总是有后悔药可以吃的。当你用$ git reset --hard HEAD^回退到add distributed版本时，再想恢复到append GPL，就必须找到append GPL的commit id。Git提供了一个命令git reflog用来记录你的每一次命令：

EBJ1263:learn_git tao2.zhang$ git reflog
bf93d54 (HEAD -> master) HEAD@{0}: reset: moving to bf93d5
1d8e5ba HEAD@{1}: reset: moving to HEAD^
bf93d54 (HEAD -> master) HEAD@{2}: commit: append GPL
1d8e5ba HEAD@{3}: commit: add distributed
1a6f842 HEAD@{4}: commit (initial): wrote a readme file

总结(版本回退)：

HEAD指向的版本就是当前版本，因此，Git允许我们在版本的历史之间穿梭，使用命令git reset --hard commit_id。
穿梭前，用git log可以查看提交历史，以便确定要回退到哪个版本。
要重返未来，用git reflog查看命令历史，以便确定要回到未来的哪个版本。

工作区和暂存区

之前有说过git工作流，现在说一下工作区和暂存区。

工作区（Working Directory）
就是你在电脑里能看到的目录，比如我们的示例learn_git文件夹就是一个工作区：

EBJ1263:learn_git tao2.zhang$ ls
readme.txt

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

EBJ1263:learn_git tao2.zhang$ ls -a
.       ..      .git        readme.txt

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

工作区&版本库

分支和 HEAD的概念我们以后再说。
前面讲了我们把文件往Git版本库里添加的时候，是分两步执行的：
第一步是用 git add把文件添加进去，实际上就是把文件修改添加到暂存区；
第二步是用 git commit提交更改，实际上就是把暂存区的所有内容提交到当前分支。
因为我们创建Git版本库时，Git自动为我们创建了唯一一个master分支，所以，现在，git commit就是往master分支上提交更改。
可以简单理解为，需要提交的文件修改通通放到暂存区，然后，一次性提交暂存区的所有修改。

俗话说，实践出真知。现在，我们再练习一遍，先对readme.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查看一下状态：

EBJ1263:learn_git tao2.zhang$ vim readme.txt 
EBJ1263:learn_git tao2.zhang$ vim LICENSE
EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git checkout -- ..." to discard changes in working directory)

    modified:   readme.txt

Untracked files:
  (use "git add ..." to include in what will be committed)

    LICENSE

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

Git非常清楚地告诉我们，readme.txt被修改了，而LICENSE还从来没有被添加过，所以它的状态是Untracked。
现在，使用两次命令git add，把readme.txt和LICENSE都添加后，用git status再查看一下：

 git status
On branch master
Changes to be committed:
  (use "git reset HEAD ..." to unstage)

    new file:   LICENSE
    modified:   readme.txt

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

git add后暂存区的状态

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

EBJ1263:learn_git tao2.zhang$ ls
LICENSE     readme.txt
EBJ1263:learn_git tao2.zhang$ git add LICENSE readme.txt 
EBJ1263:learn_git tao2.zhang$ git commit -m "add one line on readme.txt create a new file LICENSE"
[master ead6da7] add one line on readme.txt create a new file LICENSE
 2 files changed, 2 insertions(+)
 create mode 100644 LICENSE
EBJ1263:learn_git tao2.zhang$ git status
On branch master
nothing to commit, working tree clean

一旦提交后，如果你又没有对工作区做任何修改，那么工作区就是“干净”的.
现在版本库变成了这样，暂存区就没有任何内容了：

git-stage-after-commit

管理修改--深入理解

如果完全掌握了暂存区的概念。下面，我们要讨论的就是，为什么Git比其他版本控制系统设计得优秀，因为Git跟踪并管理的是修改，而非文件。
什么是修改？比如你新增了一行，这就是一个修改，删除了一行，也是一个修改，更改了某些字符，也是一个修改，删了一些又加了一些，也是一个修改，甚至创建一个新文件，也算一个修改。
为什么说Git管理的是修改，而不是文件呢？我们还是做实验。第一步，对readme.txt做一个修改，比如加一行内容：

$ cat 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.

然后，添加：

$ git add readme.txt
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD ..." to unstage)
#
#       modified:   readme.txt
#

然后，再修改readme.txt：

$ cat 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.

提交：

$ git commit -m "git tracks changes"
[master 519219b] git tracks changes
 1 file changed, 1 insertion(+)

提交后，再看看状态：

$ git status
On branch master
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git checkout -- ..." to discard changes in working directory)

    modified:   readme.txt

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

怎么第二次的修改没有被提交？

别激动，我们回顾一下操作过程：

第一次修改 -> git add -> 第二次修改 -> git commit
你看，我们前面讲了，Git管理的是修改，当你用git add命令后，在工作区的第一次修改被放入暂存区，准备提交，但是，在工作区的第二次修改并没有放入暂存区，所以，git commit只负责把暂存区的修改提交了，也就是第一次的修改被提交了，第二次的修改不会被提交。
提交后，用git diff HEAD -- readme.txt命令可以查看工作区和版本库里面最新版本的区别：

$ git diff HEAD -- readme.txt 
diff --git a/readme.txt b/readme.txt
index 76d770f..a9c5755 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,4 +1,4 @@
 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.
+Git tracks changes of files.

可见，第二次修改确实没有被提交。
那怎么提交第二次修改呢？你可以继续git add再git commit，也可以别着急提交第一次修改，先git add第二次修改，再git commit，就相当于把两次修改合并后一块提交了：

第一次修改 -> git add -> 第二次修改 -> git add -> git commit

好，现在，把第二次修改提交了。

关于git diff

-----------------------版本库--------------------------------------------
                                         a                        a
                                         |                          |
                                 git diff --cached                  |
                                         |                          |
                                         b
----------------暂存区----------------------                      git diff HEAD
                        a
                        |                                            |
                     git diff                                        |
                        |                                            |
                        b                                          b
---------------工作区----------------------------------------------------

小结

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

撤销修改

三种情况：

场景一：当你改乱了工作区某个文件的内容，想直接丢弃工作区的修改时，用命令git checkout -- file。
场景二：当你不但改乱了工作区某个文件的内容，还添加到了暂存区时，想丢弃修改，分两步，第一步用命令git reset HEAD ，就回到了场景1，第二步按场景1操作。
场景三：已经提交了不合适的修改到版本库时，想要撤销本次提交，参考[版本回退]不过前提是没有推送到远程库。
具体练习演示：
场景一：

EBJ1263:learn_git tao2.zhang$ vim readme.txt 
EBJ1263:learn_git tao2.zhang$ cat 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.
My stupid boss still prefers SVN.
EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes not staged for commit:
  (use "git add ..." to update what will be committed)
  (use "git checkout -- ..." to discard changes in working directory)

    modified:   readme.txt

no changes added to commit (use "git add" and/or "git commit -a")
EBJ1263:learn_git tao2.zhang$ git checkout -- readme.txt 
EBJ1263:learn_git tao2.zhang$ cat 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.

注：命令git checkout -- readme.txt意思就是，把readme.txt文件在工作区的修改全部撤销，这里有两种情况：
一种是readme.txt自修改后还没有被放到暂存区，现在，撤销修改就回到和版本库一模一样的状态；
一种是readme.txt已经添加到暂存区后，又作了修改，现在，撤销修改就回到添加到暂存区后的状态。
总之，就是让这个文件回到最近一次git commit或git add时的状态（使工作区文件与暂存区或仓库区保持一致）。
场景二：

EBJ1263:learn_git tao2.zhang$ vim readme.txt 
EBJ1263:learn_git tao2.zhang$ git add readme.txt
EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes to be committed:
  (use "git reset HEAD ..." to unstage)

    modified:   readme.txt

EBJ1263:learn_git tao2.zhang$ cat 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.
My stupid boss still prefers SVN.
EBJ1263:learn_git tao2.zhang$ git reset HEAD readme.txt 
Unstaged changes after reset:
M   readme.txt
EBJ1263:learn_git tao2.zhang$ git checkout -- readme.txt 
EBJ1263:learn_git tao2.zhang$ cat 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.

用命令git reset HEAD 可以把暂存区的修改撤销掉（unstage），重新放回工作区。
场景三:
场景三其实我们知道如何处理：即版本回退（现在，假设你不但改错了东西，还从暂存区提交到了版本库，怎么办呢？还记得[版本回退]吗？可以回退到上一个版本。不过，这是有条件的，就是你还没有把自己的本地版本库推送到远程。还记得Git是分布式版本控制系统吗？我们后面会讲到远程版本库，一旦你把stupid boss提交推送到远程版本库，你就真的惨了……
）。

文件删除

涉及2个命令：git rm与git checkout --file
两种情况：

情况1：工作区删，版本库也删
情况2：工作区误删，从版本库恢复
演示：
情况一：

EBJ1263:learn_git tao2.zhang$ vim test_del.txt 
EBJ1263:learn_git tao2.zhang$ git add test_del.txt 
EBJ1263:learn_git tao2.zhang$ git commit - m "del demo"
error: pathspec '-' did not match any file(s) known to git.
error: pathspec 'm' did not match any file(s) known to git.
error: pathspec 'del demo' did not match any file(s) known to git.
EBJ1263:learn_git tao2.zhang$ git commit -m "del demo"
[master cc24c06] del demo
 1 file changed, 1 insertion(+)
 create mode 100644 test_del.txt
EBJ1263:learn_git tao2.zhang$ rm test_del.txt 
EBJ1263:learn_git tao2.zhang$ git rm tetest_del.txt
fatal: pathspec 'tetest_del.txt' did not match any files
EBJ1263:learn_git tao2.zhang$ git status
On branch master
Changes not staged for commit:
  (use "git add/rm ..." to update what will be committed)
  (use "git checkout -- ..." to discard changes in working directory)

    deleted:    test_del.txt

no changes added to commit (use "git add" and/or "git commit -a")
EBJ1263:learn_git tao2.zhang$ git rm test_del.txt
rm 'test_del.txt'
EBJ1263:learn_git tao2.zhang$ git commit -m "remove test_del.txt from reposity"
[master 0c38d86] remove test_del.txt from reposity
 1 file changed, 1 deletion(-)
 delete mode 100644 test_del.txt

情况二：

EBJ1263:learn_git tao2.zhang$ vim test_recon.txt
EBJ1263:learn_git tao2.zhang$ git add test_recon.txt 
EBJ1263:learn_git tao2.zhang$ git commit -m "wrong remove demo"
[master 063b798] wrong remove demo
 1 file changed, 1 insertion(+)
 create mode 100644 test_recon.txt
EBJ1263:learn_git tao2.zhang$ rm test_recon.txt
EBJ1263:learn_git tao2.zhang$ ls
LICENSE     readme.txt
EBJ1263:learn_git tao2.zhang$ git checkout --test_recon.txt
EBJ1263:learn_git tao2.zhang$ ls
LICENSE     readme.txt  test_recon.txt

[git入门到应用一天搞定（上）]2019-04-05