git 版本控制工具（一）

创建版本库

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

创建版本库流程：

1、电脑上选择一个位置，创建一个空目录 learngit；（pwd可以用来显示当前目录的位置） 

2、通过  git init 命令把这个目录变成Git可以管理的仓库。运行完成之后，会发现当前目录下多了一个 .git 的目录（默认隐藏）。这个目录是用来跟踪管理版本库的，不要随意修改里面的文件，防止破坏Git仓库。

注：不是必须在空目录下创建Git仓库，选择一个已有东西的目录也是可以的。所有的版本控制系统，只能跟踪文本文件的改动。

添加文件到版本库

在刚才创建的目录下新建一个 readme.txt 文件，内容如下：

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

注：一定要放在 learngit 目录下。

1、用命令 git add 告诉Git，把文件添加到仓库：

$ git add readme.txt

 执行命令后没有任何显示，表示添加成功

2、用命令 git commit 告诉Git，把文件提交到仓库：

$ git commit -m "wrote a readme file"
[master (root-commit) eaadf4e] wrote a readme file
 1 file changed, 2 insertions(+)
 create mode 100644 readme.txt

-m 后面输入的是本次提交的说明，可以输入任何内容，最好是便于理解你本次提交所涉及的改动，命令执行成功后会提示你，1 file change ：一个文件被改动（我们添加的readme.txt文件）；2 insertions：插入了两行内容（readme.txt有两行内容）

注：git add <file> 可以反复多次使用，添加多个文件

修改文件并提交：

我们已经成功添加并提交了一个readme.txt文件，继续修改readme.txt文件，改成如下内容：

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

修改刚才的readme.txt 文件：

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

现在，运行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.txt

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

git status 命令可以让我们时刻掌握仓库当前的状态，上面的命令输出告诉我们，readme.txt 被修改过了，但还没有准备提交的修改。

当我们想要看看具体修改了什么内容时，可以使用git diff 这个命令：

$ git diff readme.txt 
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，从上面的命令输出我们可以看到，我们在第一行添加了一个distribute单词，

知道readme.txt 作了什么修改后，再把它提交到仓库就放心多了，提交修改和提交新文件是一样的，第一步git add ；在执行第二部之前，我们再运行git status 看看当前仓库的状态：

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

	modified:   readme.txt

git status 告诉我们，将要被提交的修改包括readme.txt,下一步，就可以放心的提交了：

$ git commit -m "add distributed"
[master e475afc] add distributed
 1 file changed, 1 insertion(+), 1 deletion(-)

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

$ git status
On branch master
nothing to commit, working tree clean

Git 告诉我们当前没有需要提交的修改，而且，工作目录是干净的。

版本回退：

刚刚学习了如何去修改文件，然后把修改提交到Git版本库,再尝试一次，修改readme.txt 文件如下：

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

然后尝试提交：

$ git add readme.txt
$ git commit -m "append GPL"
[master 1094adb] append GPL
 1 file changed, 1 insertion(+), 1 deletion(-)

像这样对文件不断进行修改，然后提交修改到版本库里。就相当于保存了一个快照，这个快照在Git中被称为commit。一旦你把文件改乱了或者误删了，可以从最近的一个commit恢复，然后继续工作，而不是把几个月的工作成果全部丢失了。

现在我们有三个版本被提交到Git仓库中，分别是：

版本一：wrote a readme 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提供了一个查看历史记录的命令。在Git中，我们用 git log 命令查看：

$ git log
commit 1094adb7b9b3807259d8cb349e7df1d4d6477073 (HEAD -> master)
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 21:06:15 2018 +0800

    append GPL

commit e475afc93c209a690c39c13a46716e8fa000c366
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 21:03:36 2018 +0800

    add distributed

commit eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 20:59:18 2018 +0800

    wrote a readme file

git log命令显示从最近到最远的提交日志，我们可以看到三次提交 ，最近的一次是append GPL，上一次是 add distributed，最早的一次是wrote a readme file。

如果感觉输出信息过多，可以试试加上 --pretty=onelline参数，结果就是：

$ git log --pretty=oneline
1094adb7b9b3807259d8cb349e7df1d4d6477073 (HEAD -> master) append GPL
e475afc93c209a690c39c13a46716e8fa000c366 add distributed
eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0 wrote a readme file

这里需要解释的是前面这一大串 1094adb...  的是 commit id（版本号），和SVN不一样，Git的commit id不是1，2，3......递增的数字，而是一个SHA1计算出来的一个非常大的数字，用十六进制表示，并且每个人的commit id都不一样，以你自己的为准。至于为什么用这么一大串数字表示，因为Git 是分布式的版本控制系统，后面我们还要研究多人在同一个版本库里工作，如果大家都用1，2，3...作为版本号，那肯定就冲突了。

每提交一个新版本，Git就会把它们自动串成一条时间线。如果使用可视化工具查看Git历史，就可以更清楚的看到提交历史的时间线：

 现在将readme.txt 回退到上一个版本，也就是add distributed该怎么做呢？

首先，Git必须知道当前版本是那个版本，在Git中，用HEAD表示当前版本，也就是最新的提交1094adb... ，上一个版本就是HEAD^，上上一个版本就是HEAD^^，当然往上100个版本不能写100个^，写成HEAD~100。

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

$ git reset --hard HEAD^
HEAD is now at e475afc add distributed

--hard 参数后面再讲。

查看readme.txt 的内容是不是add distributed：

$ cat readme.txt
Git is a distributed version control system.
Git is free software.

果然被还原了。

还可以继续回退到上一个版本，但是先让我们用git log看看现在版本库的状态：

$ git log
commit e475afc93c209a690c39c13a46716e8fa000c366 (HEAD -> master)
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 21:03:36 2018 +0800

    add distributed

commit eaadf4e385e865d25c48e7ca9c8395c3f7dfaef0
Author: Michael Liao <askxuefeng@gmail.com>
Date:   Fri May 18 20:59:18 2018 +0800

    wrote a readme file

最新的append GPL 版本已经看不到了，那我们想回去的话该怎么办。有两种情况：

1、当你上面的命令行窗口没有被关闭时，你可以找到append GPL的commit id是 1094adb... ，，于是就可以指定回到未来的某个版本：

$ git reset --hard 1094a
HEAD is now at 83b0afe append GPL

这里的话版本号没必要写全，前几位就可以，Git会自己去找。当然也不能只写一两位，防止重复。再看看readme.txt 的内容：

$ cat readme.txt
Git is a distributed version control system.
Git is free software distributed under the GPL.

果然，恢复到了最新的版本。

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

 改为指向 add distributed：

然后顺便把工作区的文件更新了，所以你让HEAD指向那个版本号，你就把当前版本定位在哪。

2、当你不小心关掉了命令行，想恢复到最新版本找不到 commit id怎么办？

Git提供了一个命令 git reflog 用来记录你的每一次命令：

$ git reflog
e475afc HEAD@{1}: reset: moving to HEAD^
1094adb (HEAD -> master) HEAD@{2}: commit: append GPL
e475afc HEAD@{3}: commit: add distributed
eaadf4e HEAD@{4}: commit (initial): wrote a readme file

从输出可知，append GPL 的commit id 是 1094adb，现在，你又可以将版本恢复到最新的了

工作区和暂存区

工作区（Working Directory）

就是在你电脑里能看到的目录，比如learngit文件夹就是一个工作区。

版本库（Repository）

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

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查看一下状态：

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

Untracked files:
  (use "git add <file>..." 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 <file>..." to unstage)

	new file:   LICENSE
	modified:   readme.txt

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

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

$ git commit -m "understand how stage works"
[master e43a48b] understand how stage works
 2 files changed, 2 insertions(+)
 create mode 100644 LICENSE

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

$ git status
On branch master
nothing to commit, working tree clean

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

 管理修改

为什么Git比其他版本控制系统设计的更优秀，因为Git跟踪并管理的是修改，而不是文件。

修改就是比如你新增了一行，删除了一行，更改了某些字符，删了一些又加了一些，甚至创建一个新文件，这些都算是一个修改。

为什么说Git管理的是修改，而不是文件呢？下面举例说明：

1、对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 <file>..." 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 <file>..." to update what will be committed)
  (use "git checkout -- <file>..." 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，就相当于把两次修改合并后一块提交了。

撤销修改

当你在文档中添加了一行：

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

当你准备提交的时候，你突然发现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.txt

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

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

$ git checkout -- readme.txt

命令git checkout -- readme.txt意思就是，把readme.txt文件在工作区的修改全部撤销，这里有两种情况：

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

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

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

现在，看啊可能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 checkout -- file 命令中的 -- 很重要，没有--，就变成了”切换到另一个分支“的命令，我们在后面的分支管理中会再次遇到git checkout命令。

现在假定凌晨三点，你不但写了一些胡话，还git add到暂存区了：

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

$ git add readme.txt

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

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

	modified:   readme.txt

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

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

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

还记得如何丢弃工作区的修改吗？

$ git checkout -- readme.txt

$ git status
On branch master
nothing to commit, working tree clean

现在，假设你不但改错了东西，还从暂存区提交到了版本库，怎么办呢？还记得版本回退一节吗？可以回退到上一个版本。不过，这是有条件的，就是你还没有把自己的本地版本库推送到远程。还记得Git是分布式版本控制系统吗？我们后面会讲到远程版本库，一旦你把stupid boss提交推送到远程版本库，你就真的惨了……

小结：

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

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

场景3：已经提交了不合适的修改到版本库时，想要撤销本次提交，参考版本回退一节，不过前提是没有推送到远程库。

删除文件

在Git中，删除也是一个修改操作，先添加一个新文件test.txt到git并提交：

$ git add test.txt

$ git commit -m "add test.txt"
[master b84166e] add test.txt
 1 file changed, 1 insertion(+)
 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

$ git rm test.txt
rm 'test.txt'

$ git commit -m "remove test.txt"
[master d46f35e] remove test.txt
 1 file changed, 1 deletion(-)
 delete mode 100644 test.txt

现在，文件就从版本库中被删除了。

另一种情况是删错了，因为版本库里还有呢，所以可以很轻松的把误删的文件恢复到最新版本：

$ git checkout -- test.txt

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

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