Git & GitHub[本地仓库]

1. Git介绍

1.1 版本控制

什么是版本控制？

我们为什么要关心它呢？版本控制是一种记录一个或若干文件内容变化，以便将来查阅特定版本修订情况的系统

为什么要使用版本控制?

软件开发中采用版本控制系统是个明智的选择。有了它你就可以将某个文件回溯到之前的状态，甚至将整个项目都回退到过去某个时间的状态。就算你乱来一气把整个项目中的文件改的改删的删，你也照样可以轻松恢复到原先的样子。但额外增加的工作量却微乎其微。你可以比较文件的变化细节，查出最后是谁修改了哪个地方，从而找出导致怪异问题出现的原因，又是谁在何时报告了某个功能缺陷等等。

1.2 集中化的版本控制系统

集中化的版本控制系统诸如 CVS，svn 以及 Perforce 等，都有一个单一的集中管理的服务器，保存所有文件的修订版本，而协同工作的人们都通过客户端连到这台服务器，取出最新的文件或者提交更新。多年以来，这已成为版本控制系统的标准做法

image.png

这种做法带来了许多好处，现在，每个人都可以在一定程度上看到项目中的其他人正在做些什么。而管理员也可以轻松掌控每个开发者的权限，并且管理一个集中化的版本控制系统; 要远比在各个客户端上维护本地数据库来得轻松容易

事分两面，有好有坏。这么做最显而易见的缺点是中央服务器的单点故障。如果服务器宕机一小时，那么在这一小时内，谁都无法提交更新，也就无法协同工作。

(并不是说服务器故障了就没有办法写代码了,只是在服务器故障的情况下,编写的代码是没有办法得到保障的.试想 svn 中央服务器挂机一天.你还拼命写了一天代码,其中 12 点之前的代码都是高质量可靠的,而且有很多闪光点.而 12 点之后的代码由于你想尝试一个比较大胆的想法,将代码改的面目全非了.这样下来你 12 点之前做的工作也都白费了 有记录的版本只能是 svn 服务器挂掉时保存的版本!)

要是中央服务器的磁盘发生故障，碰巧没做备份，或者备份不够及时，就会有丢失数据的风险。最坏的情况是彻底丢失整个项目的所有历史更改记录，而被客户端偶然提取出来的保存在本地的某些快照数据就成了恢复数据的希望。但这样的话依然是个问题，你不能保证所有的数据都已经有人事先完整提取出来过。只要整个项目的历史记录被保存在单一位置，就有丢失所有历史更新记录的风险。

1.3 分布式的版本控制系统

于是分布式版本控制系统面世了。在这类系统中，像 Git，BitKeeper 等，客户端并不只提取最新版本的文件快照，而是把代码仓库完整地镜像下来。这么一来，任何一处协同工作用的服务器发生故障，事后都可以用任何一个镜像出来的本地仓库恢复。因为每一次的提取操作，实际上都是一次对代码仓库的完整备份

image.png

更进一步，许多这类系统都可以指定和若干不同的远端代码仓库进行交互。籍此，你就可以在同一个项目中分别和不同工作小组的人相互协作。

分布式的版本控制系统在管理项目时 存放的不是项目版本与版本之间的差异.它存的是索引(所需磁盘空间很少 所以每个客户端都可以放下整个项目的历史记录)

分布式的版本控制系统出现之后,解决了集中式版本控制系统的缺陷:

  1. 断网的情况下也可以进行开发(因为版本控制是在本地进行的)
  2. 使用 github 进行团队协作,哪怕 github 挂了 每个客户端保存的也都是整个完整的项目(包含历史记录的!!!)

1.4 Git安装

git下载地址 地址 : https://git-scm.com/download/win (windows版)

下载完安装包之后，双击 exe 安装包，可以看到如下图窗口界面，一直点击

完成安装之后，就可以使用命令行的 git 工具（已经自带了 ssh 客户端）;图示如下:

image.png

当你点击 git bash Here 菜单之后，可以看到一个终端窗口，在终端里面输入命令 git —version，如果可以看到 git 的版本信息，则说明安装成功，如下图所示：

image.png

2.Git的特点

在开始学习 Git 的时候，请不要尝试把各种概念和其他版本控制系统（诸如Subversion 和 Perforce 等）相比拟，否则容易混淆每个操作的实际意义。Git 在保存和处理各种信息的时候，虽然操作起来的命令形式非常相近，但它与其他版本控制系统的做法颇为不同。理解这些差异将有助于你准确地使用 Git 提供的各种工具。

2.1直接记录快照，而非差异比较

Git 和其他版本控制系统的主要差别在于，Git 只关心文件数据的整体是否发生变化，而大多数其他系统则只关心文件内容的具体差异。这类系统（CVS，Subversion，Perforce，Bazaar 等等）每次记录有哪些文件作了更新，以及都更新了哪些行的什么内容. (下图)其他系统在每个版本中记录着各个文件的具体差异

image.png

Git 并不保存这些前后变化的差异数据。实际上，Git 更像是把变化的文件作快照后，记录在一个微型的文件系统中。每次提交更新时，它会纵览一遍所有文件的指纹信息并对文件作一快照，然后保存一个指向这次快照的索引。为提高性能，若文件没有变化，Git 不会再次保存，而只对上次保存的快照作一链接。Git 的工作方式就像下图所示（保存每次更新时的文件快照）

image.png

这是 Git 同其他系统的重要区别。它完全颠覆了传统版本控制的套路，并对各个环节的实现方式作了新的设计。Git 更像是个小型的文件系统，但它同时还提供了许多以此为基础的超强工具，而不只是一个简单的 VCS。稍后在讨论 Git 分支管理的时候，我们会再看看这样的设计究竟会带来哪些好处。

2.2 近乎所有操作都是本地执行

在 Git 中的绝大多数操作都只需要访问本地文件和资源，不用连网。但如果用 CVCS 的话，差不多所有操作都需要连接网络。因为 Git 在本地磁盘上就保存着所有当前项目的历史更新，所以处理起来速度飞快。

2.3 时刻保持数据完整性

在保存到 Git 之前，所有数据都要进行内容的校验和计算，并将此结果作为数据的唯一标识和索引。换句话说，不可能在你修改了文件或目录之后，Git 一无所知。这项特性作为 Git 的设计哲学，建在整体架构的最底层。所以如果文件在传输时变得不完整，或者磁盘损坏导致文件数据缺失，Git 都能立即察觉。Git 使用 SHA-1 算法计算数据的校验，通过对文件的内容或目录的结构计算出一个 SHA-1 哈希值，作为指纹字符串。该字串由 40 个十六进制字符（0-9 及 a-f）组成，看起来就像是：

24b9da6552252987aa493b52f8696cd6d3b00373

Git 的工作完全依赖于这类指纹字串，所以你会经常看到这样的哈希值。实际上，所有保存在 Git 数据库中的东西都是用此哈希值来作索引的，而不是靠文件名。

2.4 多数操作仅添加数据

常用的 Git 操作大多仅仅是把数据添加到数据库。因为任何一种不可逆的操作，比如删除数据，都会使回退或重现历史版本变得困难重重。在别的VCS 中，若还未提交更新，就有可能丢失或者混淆一些修改的内容，但在 Git 里，一旦提交快照之后就完全不用担心丢失数据，特别是养成定期推送到其他仓库的习惯的话。

这种高可靠性令我们的开发工作安心不少，尽管去做各种试验性的尝试好了，再怎样也不会弄丢数据。

2.5 文件的三种状态

对于任何一个文件，在 Git 内都只有三种状态（Git 外的状态就是一个普通文件）：

已提交（committed）

  1. 已提交表示该文件已经被安全地保存在本地数据库中了；

已修改（modified）

  1. 已修改表示修改了某个文件，但还没有提交保存；

已暂存（staged）

  1. 已暂存表示把已修改的文件放在下次提交时要保存的清单中

由此我们看到 Git 管理项目时，文件流转的三个工作区域：

image.png

2.6 Git工作流程

每个项目都有一个 Git 目录（.git ）它是 Git 用来保存元数据和对象数据库的地方。该目录非常重要，每次克隆镜像仓库的时候，实际拷贝的就是这个目录里

面的数据。

  1. 在工作目录中修改某些文件。
    1. 从项目中取出某个版本的所有文件和目录，用以开始后续工作的叫做工作目录。这些文件实际上都是从 Git 目录中的压缩对象数据库中提取出来的，接下来就可以在工作目录中对这些文件进行编辑。
  2. 保存到暂存区域，对暂存区做快照。
    1. 暂存区域只不过是个简单的文件，一般都放在 Git 目录中。有时候人们会把这个文件叫做索引文件，不过标准说法还是叫暂存区域。
  3. 提交更新，将保存在暂存区域的文件快照永久转储到本地数据库（Git 目录） 中

我们可以从文件所处的位置来判断状态：如果是Git目录中保存着的特定版本文件，就属于已提交状态；如果作了修改并已放入暂存区域，就属于已暂存状态；如果自上次取出后，作了修改但还没有放到暂存区域，就是已修改状态。

3. Git基本操作

3.1 Git初始化配置

一般在新的系统上，我们都需要先配置下自己的 Git 工作环境。配置工作只需一次，以后升级时还会沿用现在的配置。当然，如果需要，你随时可以用相同的命令修改已有的配置。

Git 提供了一个叫做 git config 的命令来配置或读取相应的工作环境变量而正是由这些环境变量，决定了 Git 在各个环节的具体工作方式和行为。这些变量可以存放在以下三个不同的地方：

  1. /etc/gitconfig 文件：系统中对所有用户都普遍适用的配置。若使用 gitconfig 时用 —system 选项，读写的就是这个文件。
  2. ~/.gitconfig 文件：用户目录下的配置文件只适用于该用户。若使用 gitconfig 时用 —global 选项，读写的就是这个文件。
  3. .git/config 文件：当前项目的 Git 目录中的配置文件（也就是工作目录中的 .git/config 文件）这里的配置仅仅针对当前项目有效。

每一个级别的配置都会覆盖上层的相同配置

配置内容

第一个要配置的是你个人的用户名称和电子邮件地址。这两条配置很重要，每次 Git 提交时都会引用这两条信息，说明是谁提交了更新，所以会随更新内容一起被永久纳入历史记录：

$ git config —global user.name “damu” (姓名)

$ git config —global user.email xxx@xxx.com (邮箱)

要检查已有的配置信息，可以使用 git config —list 命令

删除配置信息 git config —global —unset user.email

4. Git本地命令

1. 初始化新仓库

命令: git init

解析:要对现有的某个项目开始用 Git 管理，只需到此项目所在的目录，执行：git init

作用：初始化后，在当前目录下会出现一个名为 .git 的目录，所有 Git 需要的数据和资源都存放在这个目录中。不过目前，仅仅是按照既有的结构框架初始化好了里边所有的文件和目录，但我们还没有开始跟踪管理项目中的任何一个文件。

2. 文件的状态

工作目录下面的所有文件都不外乎这两种状态：已跟踪 或 未跟踪

已跟踪的文件是指本来就被纳入版本控制管理的文件，在上次快照中有它们的记录，工作一段时间后，它们的状态可能是已提交，已修改或者已暂存

所有其他文件都属于未跟踪文件。它们既没有上次更新时的快照，也不在当前的暂存区域。

初次克隆某个仓库时，工作目录中的所有文件都属于已跟踪文件，且状态为已提交；在编辑过某些文件之后，Git 将这些文件标为已修改。我们逐步把这些修改过的文件放到暂存区域，直到最后一次性提交所有这些暂存起来的文件。使用 Git 时的文件状态变化周期如下图所示

image.png

3. 检查当前文件状态

命令：git status

作用：确定文件当前处于什么状态

文件的状态:

  • 未跟踪
  • 已跟踪
    • 已提交
    • 已修改
    • 已暂存

3.1 未跟踪文件

如果创建一个新文件 README,保存退出后运行 git status 会看到该文件出现在未跟踪文件列表中:

  1. // 控制台输出
  2. On branch master
  3. Untracked files:
  4.  (use "git add <file>..." to include in what will be committed)
  5.      README
  6. nothing added to commit but untracked files present (use "git add" to 
  7. track)

在状态报告中可以看到新建的 README 文件出现在“Untracked files”下面。未跟踪的文件意味着 Git 在之前的快照（提交）中没有这些文件；Git 不会自动将之纳入跟踪范围，除非你明明白白地告诉它“我需要跟踪该文件”，因而不用担心把临时文件什么的也归入版本管理。

4. 跟踪新文件(暂存)

命令: git add 文件名

作用:跟踪一个新文件

再次运行 git status 命令，会看到 README 文件已被跟踪，并处于暂存状态：

  1. Changes to be committed:
  2.  (use "git reset HEAD <file>..." to unstage)
  3.      new file: README

只要在 “Changes to be committed” 这行下面的，就说明是已暂存状态。如果此时提交，那么该文件此时此刻的版本将被留存在历史记录中。在 git add 后面可以指明要跟踪的文件或目录路径。如果是目录的话，就说明要递归跟踪该目录下的所有文件。

（译注：其实 git add 的潜台词就是把目标文件快照放入暂存区域，也就是 add file into staged area，同时未曾跟踪过的文件标记为已跟踪。）

5.修改暂存区文件

现在 README 文件都已暂存，下次提交时就会一并记录到仓库。假设此时，你想要在 README 里再加条注释(修改了文件)，重新编辑存盘后，准备好提交(提交到暂存区)。不过且慢，再运行 git status 看看：

  1. On branch master
  2. Changes to be committed:
  3.  (use "git reset HEAD <file>..." to unstage)
  4.      new file: README
  5. Changes not staged for commit:
  6.  (use "git add <file>..." to update what will be committed)
  7.  (use "git checkout -- <file>..." to discard changes in working directory)
  8.          modified: README

README 文件出现了两次！一次算已修改，一次算已暂存，这怎么可能呢？好吧，实际上 Git 只不过暂存了你运行 git add 命令时的版本，如果现在提交，那么提交的是添加注释前的版本，而非当前工作目录中的版本。所以，运行了 git add 之后又作了修订的文件，需要重新运行 git add 把最新版本重新暂存起来

  1. $ git add README 重新提交 README 文件到暂存区
  2. $ git status 查看状态
  3. On branch master
  4. Changes to be committed:
  5.  (use "git reset HEAD <file>..." to unstage)
  6.      new file: README

6. 查看已暂存和未暂存的更新

实际上 git status 的显示比较简单，仅仅是列出了修改过的文件，如果要查看具体修改了什么地方，可以用 git diff 命令.这个命令它已经能解决我们两个问题了：当前做的哪些更新还没有暂存？有哪些更新已经暂存起来准备好了下次提交？

1.当前做的哪些更新还没有暂存？，

  1. 命令：git diff（不加参数直接输入 git diff）

2.有哪些更新已经暂存起来准备好了下次提交？

  1. 命令： git diff –cached 或者 git diff –staged(1.6.1 以上)

7. 提交更新

当暂存区域已经准备妥当可以提交时，在此之前，请一定要确认还有什么修改过的或新建的文件还没有 git add 过，否则提交的时候不会记录这些还没暂存起来的变化。所以，每次准备提交前，先用 git status 看下，是不是都已暂存起来了，然后再运行提交命令 git commit

命令：git commit

注意：这种方式会启动文本编辑器以便输入本次提交的说明默认的提交消息包含最后一次运行 git status 的输出，放在注释行里，另外开头还有一空行，供你输入提交说明。你完全可以去掉这些注释行，不过留着也没关系，多少能帮你回想起这次更新的内容有哪些。

另外也可以用 -m 参数后跟提交说明的方式，在一行命令中提交更新：

命令：git commit –m “message xxx”

提交时记录的是放在暂存区域的快照，任何还未暂存的仍然保持原状态，可以在下次提交时纳入版本管理。每一次运行提交操作，都是对你项目(暂存区)作一次快照，以后可以回到这个状态，或者进行比较

8.跳过使用暂存区域

尽管使用暂存区域的方式可以精心准备要提交的细节，但有时候这么做略显繁琐。Git 提供了一个跳过使用暂存区域的方式，只要在提交的时候，给 git commit 加上 -a 选项，Git 就会自动把所有已经跟踪过的文件暂存起来一并提交，从而跳过 git add 步骤

命令: git commit -a

9.移除文件

要从 Git 中移除某个文件，就必须要从已跟踪文件清单中注册删除（确切地说，是在暂存区域注册删除），然后提交。可以用 git rm 命令完成此项工作，并连带从工作目录中删除指定的文件，这样以后就不会出现在未跟踪文件清单中了。

命令: git rm 文件名

1.从工作目录中手工删除文件

git status

  1. On branch master
  2. Changes not staged for commit:
  3.  (use "git add/rm <file>..." to update what will be committed)
  4.  (use "git checkout -- <file>..." to discard changes in working directory)
  5.      deleted: grit.gemspec
  6. no changes added to commit (use "git add" and/or "git commit -a")

2. 再运行 git rm 记录此次移除文件的操作

git status

  1. On branch master
  2. Changes to be committed:
  3.  (use "git reset HEAD <file>..." to unstage)
  4.  deleted: grit.gemspec

3. 最后提交的时候，该文件就不再纳入版本管理了

10.文件改名

命令: git mv 原文件名 修改的文件名

  1. git mv file.from file.to
  2. git status
  3.     On branch master
  4.     Changes to be committed:
  5.      (use "git reset HEAD <file>..." to unstage)
  6.          renamed: README.txt -> README

其实，运行 git mv 就相当于运行了下面三条命令：

  1. $ mv README.txt README
  2. $ git rm README.txt
  3. $ git add README

11. 查看历史记录

命令: git log

在提交了若干更新，又或者克隆了某个项目之后，你也许想回顾下提交历史(git comit)。完成这个任务最简单而又有效的工具是 git log 命令

  1. $ git log
  2. commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
  3. Author: Scott Chacon <schacon@gee-mail.com>
  4. Date: Sat Mar 15 16:40:33 2008 -0700
  5.      removed unnecessary test
  6. commit a11bef06a3f659402fe7563abf99ad00de2209e6
  7. Author: Scott Chacon <schacon@gee-mail.com>
  8. Date: Sat Mar 15 10:31:28 2008 -0700
  9.  first commit

默认不用任何参数的话，git log 会按提交时间列出所有的更新，最近的更新排在最上面。 正如你所看到的，这个命令会列出每个提交的 SHA-1 校验和、作者的名字和电子邮件地址、提交时间以及提交说明。

git log 参数

git log —pretty=oneline 单行输出

git log —oneline 单行输出

5. Git分支功能

几乎所有的版本控制系统都以某种形式支持分支。 使用分支意味着你可以把你的工作从开发主线上分离开来，以免影响开发主线。 在很多版本控制系统中，这是一个略微低效的过程——常常需要完全创建一个源代码目录的副本。对于大项目来说，这样的过程会耗费很多时间。

而 Git 的分支模型极其的高效轻量的。是 Git 的必杀技特性，也正因为这一特性，使得 Git 从众多版本控制系统中脱颖而出

5.1 分支本质

Git 的分支，其实本质上仅仅是指向提交对象的可变指针。 Git 的默认分支名字是 master。 在多次提交操作之后，你其实已经有一个指向最后那个提交对象的 master 分支。 它会在每次的提交操作中自动向前移动。

注意: Git 的 “master” 分支并不是一个特殊分支。 它就跟其它分支完全没有区别。 之所以几乎每一个仓库都有 master 分支，是因为 git init 命令默认创建它，并且大多数人都懒得去改动它

1. 图示

image.png

2. 分支原理

.git/refs 目录

这个目录中保存了分支及其对应的提交对象

3. HEAD 引用

当运行类似于 git branch (branchname) 这样的命令时，Git会取得当前所在分支最新提交对应的 SHA-1 值，并将其加入你想要创建的任何新分支中。

当你执行 git branch (branchname) 时，Git 如何知道最新提交的 SHA-1 值呢？ 答案是 HEAD 文件。

HEAD 文件是一个符号引用（symbolic reference），指向目前所在的分支。 所谓符号引用，意味着它并不像普通引用那样包含一个 SHA-1 值。它是一个指向其他引用的指针

5.2 创建分支

命令: git branch

新建分支并切换: git checkout -b name(分支名)

作用: 为你创建了一个可以移动的新的指针。 比如，创建一个 testing 分支：git branch testing。这会在当前所在的提交对象上创建一个指针

git branch 分支名 创建 一个新分支，并不会自动切换到新分支中去

image.png

5.3 删除分支

命令: git branch -d branchName(分支名)

5.4 切换分支

命令: git checkout name(分支名)

image.png

做出修改，再提交

命令：git commit -m “提交‘’

image.png

切回 master

命令：git checkout master

image.png

注意： 分支切换会改变你工作目录中的文件

在切换分支时，一定要注意你工作目录里的文件会被改变。 如果是切换到一个较旧的分支，你的工作目录会恢复到该分支最后一次提交时的样子。如果 Git 不能干净利落地完成这个任务，它将禁止切换分支

每次在切换分支前 提交一下当前分支

5.5 git branch 命令汇总

  • git branch 得到当前所有分支的一个列表
  • git branch -d name 删除分支
  • git branch -v 可以查看每一个分支的最后一次提交
  • git branch name(分支名) commitHash(提交对象哈希值) 新建一个分支并且使分支指向对应的提交对象
  • git branch –merged 查看哪些分支已经合并到当前分支 在这个列表中分支名字前没有 * 号的分支通常可以使用
  • git branch -d name(分支名) 删除已合并的分支
  • git branch -D name(分支名) 强制删除分支(无论是否已合并)
    • 删除分支注意: 不能删除head所指向的分支，你要先移动到其它分支，才能删除
  • git branch —no-merged 查看所有包含未合并工作的分支

5.6 查看当前分支所指提交对象

命令: git log —oneline –decorate

（提供这一功能的参数是 —decorate）

5.7 查看项目分叉历史

命令：git log —oneline —decorate —graph —all

5.8 合并分支

1.快进合并

命令：git merge 分支名

在合并的时候，有时候会出现”快进（fast-forward）”这个词。 由于当前 master 分支所指向的提交是你当前提交的直接上游，所以 Git 只是简单的将指针向前移动。 换句话说，当你试图合并两个分支时，如果顺着一个分支走下去能够到达另一个分支，那么 Git 在合并两者的时候，只会简单的将指针向前推进（指针右移），因为这种情况下的合并操作没有需要解决的分歧——这就叫做 “快进”

2.典型合并

命令:

当前的合并和你之前合并 hotfix 分支的时候看起来有一点不一样。 在这种情况下，你的开发历史从一个更早的地方开始分叉开来（diverged）。 因为，master 分支所在提交并不是 iss53 分支所在提交的直接祖先，Git 不得不做一些额外的工作。 出现这种情况的时候，Git 会使用两个分支的末端所指的快照（C4 和 C5）以及这两个分支的工作祖先（C2），做一个简单的三方合并

如图:

image.png

和之前将分支指针向前推进所不同的是，Git 将此次三方合并的结果做了一个新的快照并且自动创建一个新的提交指向它。 这个被称作一次合并提交，它的特别之处在于他有不止一个父提交。

image.png

需要指出的是，Git 会自行决定选取哪一个提交作为最优的共同祖先，并以此作为合并的基础；这和更加古老的 CVS 系统或者 Subversion （1.5 版本之前）不同，在这些古老的版本管理系统中，用户需要自己选择最佳的合并基础。 Git 的这个优势使其在合并操作上比其他系统要简单很多

冲突:

有时候合并操作不会如此顺利。 如果你在两个不同的分支中，对同一个文件的同一个部分进行了不同的修改，Git 就没法干净的合并它们。 如果你对 #53 问题的修改和有关 hotfix 的修改都涉及到同一个文件的同一处，在合并它们的时候就会产生合并冲突此时 Git 做了合并，但是没有自动地创建一个新的合并提交。 Git 会暂停下来，等待你去解决合并产生的冲突。 你可以在合并冲突后的任意时刻使用 git status 命令来查看那些因包含合并冲突而处于未合并（unmerged）状态的文件

任何因包含合并冲突而有待解决的文件，都会以未合并状态标识出来。

  1. <<<<<<< HEAD:index.html
  3. <div id="footer">contact : email.support@github.com</div>
  5. =======
  7. <div id="footer">
  9. please contact us at support@github.com
  11. </div>
  13. \>>>>>>> iss53:index.html

在你解决了所有文件里的冲突之后，对每个文件使用 git add 命令来将其标记为冲突已解决。

一旦暂存这些原本有冲突的文件，Git 就会将它们标记为冲突已解决

5.9 思考

自己思考的内容,不一定正确捏

试着用链表的思维去理解Git中版本的概念，将一个版本对象想象为一个链表项，链表的内容就是当前提交对象的所有内容，next就是上一个版本提交的地址。

Git 的分支，其实本质上仅仅是指向提交对象的可变指针。 他默认指向最近一次的提交对象，我们可以改变分支指针的指向，让他根据哈希值指向指定的提交对象，这样子我们就完成了版本回溯。

创建分支的时候，子分支会从父分支那边继承所有的提交对象信息（也就是一整条链表信息，相当连接起来了），在子分支上是可以提交我们自己的提交对象的，这个提交对象也是链表结构，并且这个提交对象是不会和父分支共享的，我们可以在子分支上自由的创建版本，等到合适的时候再将合适的提交对象（子分支上的提交对象）合并到主分支上（会形成一个新的提交对象）。

思考：分支有子父关系吗，是什么操作决定了分支之间的子父关系

6. Git存储

有时，当你在项目的一部分上已经工作一段时间后，所有东西都进入了混乱的状态，而这时你想要切换到另一个分支做一点别的事情。 问题是，你不想仅仅因为过会儿回到这一点而为做了一半的工作创建一次提交。 针对这个问题的答案是:git stash 命令

git stash 命令会将未完成的修改保存到一个栈上，而你可以在任何时候重新应用这些改动(git stash apply)

git stash list:查看存储

git stash apply stash@{2}

如果不指定一个储藏，Git 认为指定的是最近的储藏

git stash pop 来应用储藏然后立即从栈上扔掉它

git stash drop 加上将要移除的储藏的名字来移除它

7. 给命令配别名

Git 并不会在你输入部分命令时自动推断出你想要的命令。 如果不想每次都输入完整的 Git 命令，可以通过 git config 文件来轻松地为每一个命令设置一个别名。

  1. $ git config --global alias.co checkout
  2. $ git config --global alias.br branch 
  3. $ git config --global alias.ci commit 
  4. $ git config --global alias.st status 
  5. $ git config --global alias.st "长命令" 
  6. 当要输入 git commit 时，只需要输入 git ci

8. 撤销&重置

8.1 撤销

命令: git commit —amend

作用:这个命令会将暂存区中的文件提交。如果自上次提交以来你还未做任何修改（例如，在上次提交后马上执行了此命令），那么快照会保持不变，而你所修改的只是提交信息如果你提交后发现忘记了暂存某些需要的修改，可以像下面这样操作

  1. git commit -m 'initial commit'
  2. git add forgotten_file
  3. git commit –amend

最终你只会有一个提交 - 第二次提交将代替第一次提交的结果

命令：git reset HEAD 文件名

作用：将文件从暂存区中撤回到工作目录

命令：git checkout — 文件名

作用：将在工作目录中对文件的修改撤销

注意: git checkout -- [file] 是一个危险的命令，这很重要。 你对那个文件做的任何修改都会消失 - 你只是拷贝了另一个文件来覆盖它。除非你确实清楚不想要那个文件了，否则不要使用这个命令

8.2 HEAD

HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次提交。这表示 HEAD 将是下一次提交的父结点。通常，理解 HEAD 的最简方式，就是将它看做 当前提交的快照。

git cat-file -p HEAD

查看当前提交对象: git ls-tree -r HEAD

8.3 查看暂存区

git ls-files -s 查看暂存区当前的样子

8.4 工作目录

你可以把工作目录当做 沙盒。在你将修改提交到暂存区并记录到历史之前，可以随意更改。

9. 重置 reset

9.1 reset三部曲（commithash）

1. 移动 HEAD

reset 做的第一件事是移动 HEAD 的指向。

假设我们再次修改了 file.txt 文件并第三次提交它。 现在的历史看起来是这样

image.png

命令： git reset –soft HEAD~

这与改变 HEAD 自身不同（checkout 所做的）；reset 移动 HEAD 指向的分支。

image.png

看一眼上图，理解一下发生的事情：它本质上是撤销了上一次 git commit 命令。 当你在运行 git commit 时，Git 会创建一个新的提交，并移动 HEAD 所指向的分支来使其指向该提交。

当你将它 reset 回 HEAD~（HEAD 的父结点）时，其实就是把该分支移动回原来的位置，而不会改变索引和工作目录。 现在你可以更新索引并再次运行 git commit 来完成 git commit --amend 所要做的事情了。

2. 更新暂存区

image.png

注意 git reset HEAD~ 等同于 git reset [–mixed] HEAD~

理解一下发生的事情：它依然会撤销一上次提交，但还会取消暂存所有的东西。 于是，我们回滚到了所有 git add 和 git commit 的命令执行之前。

3. 更新工作目录

image.png

你撤销了最后的提交、git add 和 git commit 命令以及工作目录中的所有工作。

4.注意点

必须注意，--hard 标记是 reset 命令唯一的危险用法，它也是 Git 会真正地销毁数据的仅有的几个操作之一。 其他任何形式的 reset 调用都可以轻松撤消，但是 --hard 选项不能，因为它强制覆盖了工作目录中的文件。在这种特殊情况下，我们的 Git 数据库中的一个提交内还留有该文件的 v3 版本，我们可以通过 reflog 来找回它。但是若该文件还未提交，Git 仍会覆盖它从而导致无法恢复。

5.路径reset

前面讲述了 reset 基本形式的行为，不过你还可以给它提供一个作用路径。 若指定了一个路径，reset 将会跳过第 1 步，并且将它的作用范围限定为指定的文件或文件集合。 这样做自然有它的道理，因为 HEAD 只是一个指针，你无法让它同时指向两个提交中各自的一部分。 不过索引和工作目录 可以部分更新，所以重置会继续进行第 2、3 步。

现在，假如我们运行 git reset file.txt （这其实是 git reset --mixed HEAD file.txt 的简写形式，），它会：

  1.     移动 HEAD 分支的指向 （因为是文件这一步忽略）
  3.     让索引看起来像 HEAD

所以它本质上只是将 file.txt 从 HEAD 复制到索引中

image.png

image.png

6. checkout

6.1 不带路径

git checkout [branch]

运行 git checkout [branch] 与运行 git reset —hard[branch] 非常相似，它会更新三者使其看起来像 [branch]，不过有两点重要的区别

首先不同于 reset —hard，checkout 对工作目录是安全的，它会通过检查来确保不会将已更改的文件弄丢。而 reset —hard 则会不做检

查就全面地替换所有东西。

第二个重要的区别是如何更新 HEAD。 reset 会移动 HEAD 分支的指向，而 checkout 只会移动 HEAD 自身来指向另一个分支。例如，假设我们有 master 和 develop 分支，它们分别指向不同的提交；我们现在在 develop 上。 如果我们运行 git reset master，那么 develop 自身现在会和 master 指向同一个提交。而如果我们运行 gitcheckout master 的话，develop 不会移动，HEAD 自身会移动。 现在HEAD 将会指向 master。

所以，虽然在这两种情况下我们都移动 HEAD 使其指向了提交 A，但做法是非常不同的。 reset 会移动 HEAD 分支的指向，而 checkout 则移动 HEAD 自身。

image.png

6.2 带路径

git checkout commithash

运行 checkout 的另一种方式就是指定一个文件路径，这会像 reset 一样不会移动 HEAD。 它就像是 git reset —hard [branch] file。 这样对工作目录并不安全，它也不会移动 HEAD 将会跳过第 1 步 更新暂存区 和 工作目录

命令: git checkout — 

  1.         **相比于** **git reset – hard commitHash** **跟文件名的形式第一 第二步都没做**

10.数据恢复

在你使用 Git 的时候，你可能会意外丢失一次提交。 通常这是因为你强制删除了正在工作的分支，但是最后却发现你还需要这个分支；亦或者硬重置了一个分支，放弃了你想要的提交。 如果这些事情已经发生，该如何找回你的提交呢？

恢复

看起来下面的那个就是你丢失的提交，你可以通过创建一个新的分支指向这个提交来恢复它。 例如，你可以创建一个名为 recover-branch 的分支指向这个提交（ab1afef）

git branch recover-branch ab1afef

现在有一个名为 recover-branch 的分支是你的 master 分支曾经指向的地方，再一次使得前两次提交可到达了。

实例

假设你已经提交了五次

  1. $ git log --pretty=oneline
  2. ab1afef80fac8e34258ff41fc1b867c702daa24b modified repo a bit
  3. 484a59275031909e19aadb7c92262719cfcdf19a added repo.rb
  4. 1a410efbd13591db07496601ebc7a059dd55cfe9 third commit
  5. cac0cab538b970a37ea1e769cbbde608743bc96d second commit
  6. fdf4fc3344e67ab068f836878b6c4951e3b15f3d first commit

现在，我们将 master 分支硬重置到第三次提交

  1. $ git reset --hard 1a410efbd13591db07496601ebc7a059dd55cfe9
  2.     HEAD is now at 1a410ef third commit
  3. $ git log --pretty=oneline
  4.     1a410efbd13591db07496601ebc7a059dd55cfe9 third commit
  5.     cac0cab538b970a37ea1e769cbbde608743bc96d second commit
  6.     fdf4fc3344e67ab068f836878b6c4951e3b15f3d first commit

现在顶部的两个提交已经丢失了 - 没有分支指向这些提交。 你需要找出最后一次提交的 SHA-1 然后增加一个指向它的分支。 窍门就是找到最后一次的提交的 SHA-1 - 但是估计你记不起来了，对吗？

最方便，也是最常用的方法，是使用一个名叫 git reflog 的工具。当你正在工作时，Git 会默默地记录每一次你改变 HEAD 时它的值。 每一次你提交或改变分支，引用日志都会被更新

  1. $ git reflog
  2.     1a410ef HEAD@{0}: reset: moving to 1a410ef
  3.     ab1afef HEAD@{1}: commit: modified repo.rb a bit
  4.     484a592 HEAD@{2}: commit: added repo.rb
  5.      ......

git reflog 并不能显示足够多的信息。为了使显示的信息更加有用，

我们可以执行 git log -g，这个命令会以标准日志的格式输出引用日志

11. 打tag

Git 可以给历史中的某一个提交打上标签，以示重要。 比较有代表性的是人们会使用这个功能来标记发布结点（v1.0 等等）。

1. 列出标签

命令: git tag

  1. $ git tag
  2.     git tag -l 'v1.8.5*' 
  3.     v1.8.5 v1.8.5-rc0 v1.8.5-rc1 v1.8.5-rc2 v1.8.5-rc3 v1.8.5.1 v1.8.5.2 v1.8.5.3

2. 创建标签

Git 使用两种主要类型的标签：轻量标签 与 附注标签

  1. **轻量标签**很像一个不会改变的分支 - 它只是一个特定提交的引用
  1. git tag v1.4 //创建轻量标签
  2. git tag v1.4 commitHash //创建附注标签

附注标签是存储在 Git 数据库中的一个完整对象。 它们是可以被校验的；其中包含打标签者的名字、电子 邮件地址、日期时间；还有一个标签信息；通常建议 创建附注标签，这样你可以拥有以上所有信息；但是如果你只是想用一个临时的标签，或者因为某些原因不想要保存那些信息，轻量标签也是可用的

  1. git tag -a v1.4
  2. git tag -a v1.4 commitHash
  3. git tag -a v1.4 commitHash -m 'my version 1.4'

3.查看特定标签

命令 : git show tagname

git show 可以显示任意类型的对象（git 对象 树对象 提交对象 tag 对象）

4. 远程标签

默认情况下，git push 命令并不会传送标签到远程仓库服务器上。 在创建完标签后你必须显式地推送标签到 共享服务器上。你可以运行

命令 : git push origin [tagname]

如果想要一次性推送很多标签，也可以使用带有 —tags 选项的 git push 命令。这将会把所有不在远程仓库 服务器上的标签全部传送到那里。

命令： git push origin —tags

5. 删除标签

删除标签 要删除掉你本地仓库上的标签，可以使用命令 git tag -d 。例如，可以使用下面的命令删除掉 一个轻量级标签：

命令: git tag -d v1.4

应该注意的是上述命令并不会从任何远程仓库中移除这个标签，你必须使用git push :refs/tags/ 来更新你的远程仓库：

命令: git push origin :refs/tags/v1.4

6.检出标签

如果你想查看某个标签所指向的文件版本，可以使用 git checkout 命令

命令: git checkout tagname

虽然说这会使你的仓库处于“分离 头指针（detacthed HEAD）”状态。在“分离头指针”状态下，如果你做了某些更改然后提交它们，标签不会发生变化，但你的新提交将不属于任何 分支，并且将无法访问，除非访问确切的提交哈希。因此，如果你需要进行更改——比如说你正在修复旧版本的错 误——这通常需要创建一个新分支：

命令: git checkout -b version2