• Git 对象
    • tree (树) 对象
    • commit (提交) 对象

    Git 对象

    Git 是一套内容寻址文件系统。很不错。不过这是什么意思呢？
    这种说法的意思是，Git 从核心上来看不过是简单地存储键值对（key-value）。它允许插入任意类型的内容，并会返回一个键值，通过该键值可以在任何时候再取出该内容。可以通过底层命令 hash-object 来示范这点，传一些数据给该命令，它会将数据保存在 .git 目录并返回表示这些数据的键值。首先初使化一个 Git 仓库并确认 objects 目录是空的：

    1. $ mkdir test
    2. $ cd test
    3. $ git init
    4. Initialized empty Git repository in /tmp/test/.git/
    5. $ find .git/objects
    6. .git/objects
    7. .git/objects/info
    8. .git/objects/pack
    9. $ find .git/objects -type f
    10. $

    Git 初始化了 objects 目录，同时在该目录下创建了 pack 和 info 子目录，但是该目录下没有其他常规文件。我们往这个 Git 数据库里存储一些文本：

    1. $ echo 'test content' | git hash-object -w --stdin
    2. d670460b4b4aece5915caf5c68d12f560a9fe3e4

    参数 -w 指示 hash-object 命令存储 (数据) 对象，若不指定这个参数该命令仅仅返回键值。—stdin 指定从标准输入设备 (stdin) 来读取内容，若不指定这个参数则需指定一个要存储的文件的路径。该命令输出长度为 40 个字符的校验和。这是个 SHA-1 哈希值──其值为要存储的数据加上你马上会了解到的一种头信息的校验和。现在可以查看到 Git 已经存储了数据：

    1. $ find .git/objects -type f
    2. .git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4

    可以在 objects 目录下看到一个文件。这便是 Git 存储数据内容的方式──为每份内容生成一个文件，取得该内容与头信息的 SHA-1 校验和，创建以该校验和前两个字符为名称的子目录，并以 (校验和) 剩下 38 个字符为文件命名 (保存至子目录下)。

    通过 cat-file 命令可以将数据内容取回。该命令是查看 Git 对象的瑞士军刀。传入 -p 参数可以让该命令输出数据内容的类型：

    1. $ git cat-file -p d670460b4b4aece5915caf5c68d12f560a9fe3e4
    2. test content

    可以往 Git 中添加更多内容并取回了。也可以直接添加文件。比方说可以对一个文件进行简单的版本控制。首先，创建一个新文件，并把文件内容存储到数据库中：

    1. $ echo 'version 1' > test.txt
    2. $ git hash-object -w test.txt
    3. 83baae61804e65cc73a7201a7252750c76066a30

    接着往该文件中写入一些新内容并再次保存：

    1. $ echo 'version 2' > test.txt
    2. $ git hash-object -w test.txt
    3. 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a

    数据库中已经将文件的两个新版本连同一开始的内容保存下来了：

    1. $ find .git/objects -type f
    2. .git/objects/1f/7a7a472abf3dd9643fd615f6da379c4acb3e3a
    3. .git/objects/83/baae61804e65cc73a7201a7252750c76066a30
    4. .git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4

    再将文件恢复到第一个版本：

    1. $ git cat-file -p 83baae61804e65cc73a7201a7252750c76066a30 > test.txt
    2. $ cat test.txt
    3. version 1

    或恢复到第二个版本：

    1. $ git cat-file -p 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a > test.txt
    2. $ cat test.txt
    3. version 2

    需要记住的是几个版本的文件 SHA-1 值可能与实际的值不同，其次，存储的并不是文件名而仅仅是文件内容。这种对象类型称为 blob 。通过传递 SHA-1 值给 cat-file -t 命令可以让 Git 返回任何对象的类型：

    1. $ git cat-file -t 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a
    2. blob

    tree (树) 对象

    接下去来看 tree 对象，tree 对象可以存储文件名，同时也允许存储一组文件。Git 以一种类似 UNIX 文件系统但更简单的方式来存储内容。所有内容以 tree 或 blob 对象存储，其中 tree 对象对应于 UNIX 中的目录，blob 对象则大致对应于 inodes 或文件内容。一个单独的 tree 对象包含一条或多条 tree 记录，每一条记录含有一个指向 blob 或子 tree 对象的 SHA-1 指针，并附有该对象的权限模式 (mode)、类型和文件名信息。以 simplegit 项目为例，最新的 tree 可能是这个样子：

    1. $ git cat-file -p master^{tree}
    2. 100644 blob a906cb2a4a904a152e80877d4088654daad0c859      README
    3. 100644 blob 8f94139338f9404f26296befa88755fc2598c289      Rakefile
    4. 040000 tree 99f1a6d12cb4b6f19c8655fca46c3ecf317074e0      lib

    master^{tree} 表示 master 分支上最新提交指向的 tree 对象。请注意 lib 子目录并非一个 blob 对象，而是一个指向另一个 tree 对象的指针：

    1. $ git cat-file -p 99f1a6d12cb4b6f19c8655fca46c3ecf317074e0
    2. 100644 blob 47c6340d6459e05787f644c2447d2595f5d3a54b      simplegit.rb

    从概念上来讲，Git 保存的数据如图 9-1 所示。

    Git 对象 - 图1

    图 9-1. Git 对象模型的简化版

    你可以自己创建 tree 。通常 Git 根据你的暂存区域或 index 来创建并写入一个 tree 。因此要创建一个 tree 对象的话首先要通过将一些文件暂存从而创建一个 index 。可以使用 plumbing 命令 update-index 为一个单独文件 ── test.txt 文件的第一个版本 ──　创建一个 index　。通过该命令人为的将 test.txt 文件的首个版本加入到了一个新的暂存区域中。由于该文件原先并不在暂存区域中 (甚至就连暂存区域也还没被创建出来呢) ，必须传入 —add 参数;由于要添加的文件并不在当前目录下而是在数据库中，必须传入 —cacheinfo 参数。同时指定了文件模式，SHA-1 值和文件名：

    1. $ git update-index --add --cacheinfo 100644 \
    2.   83baae61804e65cc73a7201a7252750c76066a30 test.txt

    在本例中，指定了文件模式为 100644，表明这是一个普通文件。其他可用的模式有：100755 表示可执行文件，120000 表示符号链接。文件模式是从常规的 UNIX 文件模式中参考来的，但是没有那么灵活 ── 上述三种模式仅对 Git 中的文件 (blobs) 有效 (虽然也有其他模式用于目录和子模块)。

    现在可以用 write-tree 命令将暂存区域的内容写到一个 tree 对象了。无需 -w 参数 ── 如果目标 tree 不存在，调用 write-tree 会自动根据 index 状态创建一个 tree 对象。

    1. $ git write-tree
    2. d8329fc1cc938780ffdd9f94e0d364e0ea74f579
    3. $ git cat-file -p d8329fc1cc938780ffdd9f94e0d364e0ea74f579
    4. 100644 blob 83baae61804e65cc73a7201a7252750c76066a30      test.txt

    可以这样验证这确实是一个 tree 对象：

    1. $ git cat-file -t d8329fc1cc938780ffdd9f94e0d364e0ea74f579
    2. tree

    再根据 test.txt 的第二个版本以及一个新文件创建一个新 tree 对象：

    1. $ echo 'new file' > new.txt
    2. $ git update-index test.txt
    3. $ git update-index --add new.txt

    这时暂存区域中包含了 test.txt 的新版本及一个新文件 new.txt 。创建 (写) 该 tree 对象 (将暂存区域或 index 状态写入到一个 tree 对象)，然后瞧瞧它的样子：

    1. $ git write-tree
    2. 0155eb4229851634a0f03eb265b69f5a2d56f341
    3. $ git cat-file -p 0155eb4229851634a0f03eb265b69f5a2d56f341
    4. 100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
    5. 100644 blob 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a      test.txt

    请注意该 tree 对象包含了两个文件记录，且 test.txt 的 SHA 值是早先值的 "第二版" (1f7a7a)。来点更有趣的，你将把第一个 tree 对象作为一个子目录加进该 tree 中。可以用 read-tree 命令将 tree 对象读到暂存区域中去。在这时，通过传一个 —prefix 参数给 read-tree，将一个已有的 tree 对象作为一个子 tree 读到暂存区域中：

    1. $ git read-tree --prefix=bak d8329fc1cc938780ffdd9f94e0d364e0ea74f579
    2. $ git write-tree
    3. 3c4e9cd789d88d8d89c1073707c3585e41b0e614
    4. $ git cat-file -p 3c4e9cd789d88d8d89c1073707c3585e41b0e614
    5. 040000 tree d8329fc1cc938780ffdd9f94e0d364e0ea74f579      bak
    6. 100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
    7. 100644 blob 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a      test.txt

    如果从刚写入的新 tree 对象创建一个工作目录，将得到位于工作目录顶级的两个文件和一个名为 bak 的子目录，该子目录包含了 test.txt 文件的第一个版本。可以将 Git 用来包含这些内容的数据想象成如图 9-2 所示的样子。

    Git 对象 - 图2

    图 9-2. 当前 Git 数据的内容结构

    commit (提交) 对象

    你现在有三个 tree 对象，它们指向了你要跟踪的项目的不同快照，可是先前的问题依然存在：必须记往三个 SHA-1 值以获得这些快照。你也没有关于谁、何时以及为何保存了这些快照的信息。commit 对象为你保存了这些基本信息。

    要创建一个 commit 对象，使用 commit-tree 命令，指定一个 tree 的 SHA-1，如果有任何前继提交对象，也可以指定。从你写的第一个 tree 开始：

    1. $ echo 'first commit' | git commit-tree d8329f
    2. fdf4fc3344e67ab068f836878b6c4951e3b15f3d

    通过 cat-file 查看这个新 commit 对象：

    1. $ git cat-file -p fdf4fc3
    2. tree d8329fc1cc938780ffdd9f94e0d364e0ea74f579
    3. author Scott Chacon <schacon@gmail.com> 1243040974 -0700
    4. committer Scott Chacon <schacon@gmail.com> 1243040974 -0700
    6. first commit

    commit 对象的格式很简单：指明了该时间点项目快照的顶层树对象、作者/提交者信息（从 Git 设置的 user.name 和 user.email中获得)以及当前时间戳、一个空行，以及提交注释信息。

    接着再写入另外两个 commit 对象，每一个都指定其之前的那个 commit 对象：

    1. $ echo 'second commit' | git commit-tree 0155eb -p fdf4fc3
    2. cac0cab538b970a37ea1e769cbbde608743bc96d
    3. $ echo 'third commit'  | git commit-tree 3c4e9c -p cac0cab
    4. 1a410efbd13591db07496601ebc7a059dd55cfe9

    每一个 commit 对象都指向了你创建的树对象快照。出乎意料的是，现在已经有了真实的 Git 历史了，所以如果运行 git log 命令并指定最后那个 commit 对象的 SHA-1 便可以查看历史：

    1. $ git log --stat 1a410e
    2. commit 1a410efbd13591db07496601ebc7a059dd55cfe9
    3. Author: Scott Chacon <schacon@gmail.com>
    4. Date:   Fri May 22 18:15:24 2009 -0700
    6.     third commit
    8.  bak/test.txt |    1 +
    9.  1 files changed, 1 insertions(+), 0 deletions(-)
    11. commit cac0cab538b970a37ea1e769cbbde608743bc96d
    12. Author: Scott Chacon <schacon@gmail.com>
    13. Date:   Fri May 22 18:14:29 2009 -0700
    15.     second commit
    17.  new.txt  |    1 +
    18.  test.txt |    2 +-
    19.  2 files changed, 2 insertions(+), 1 deletions(-)
    21. commit fdf4fc3344e67ab068f836878b6c4951e3b15f3d
    22. Author: Scott Chacon <schacon@gmail.com>
    23. Date:   Fri May 22 18:09:34 2009 -0700
    25.     first commit
    27.  test.txt |    1 +
    28.  1 files changed, 1 insertions(+), 0 deletions(-)

    真棒。你刚刚通过使用低级操作而不是那些普通命令创建了一个 Git 历史。这基本上就是运行　git add 和 git commit 命令时 Git 进行的工作　──保存修改了的文件的 blob，更新索引，创建 tree 对象，最后创建 commit 对象，这些 commit 对象指向了顶层 tree 对象以及先前的 commit 对象。这三类 Git 对象 ── blob，tree 以及 commit ── 都各自以文件的方式保存在 .git/objects 目录下。以下所列是目前为止样例中的所有对象，每个对象后面的注释里标明了它们保存的内容：

    1. $ find .git/objects -type f
    2. .git/objects/01/55eb4229851634a0f03eb265b69f5a2d56f341 # tree 2
    3. .git/objects/1a/410efbd13591db07496601ebc7a059dd55cfe9 # commit 3
    4. .git/objects/1f/7a7a472abf3dd9643fd615f6da379c4acb3e3a # test.txt v2
    5. .git/objects/3c/4e9cd789d88d8d89c1073707c3585e41b0e614 # tree 3
    6. .git/objects/83/baae61804e65cc73a7201a7252750c76066a30 # test.txt v1
    7. .git/objects/ca/c0cab538b970a37ea1e769cbbde608743bc96d # commit 2
    8. .git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4 # 'test content'
    9. .git/objects/d8/329fc1cc938780ffdd9f94e0d364e0ea74f579 # tree 1
    10. .git/objects/fa/49b077972391ad58037050f2a75f74e3671e92 # new.txt
    11. .git/objects/fd/f4fc3344e67ab068f836878b6c4951e3b15f3d # commit 1

    如果你按照以上描述进行了操作，可以得到如图 9-3 所示的对象图。

    Git 对象 - 图3

    图 9-3. Git 目录下的所有对象

    之前我提到当存储数据内容时，同时会有一个文件头被存储起来。我们花些时间来看看 Git 是如何存储对象的。你将看到如何通过 Ruby 脚本语言存储一个 blob 对象 (这里以字符串 "what is up, doc?" 为例) 。使用 irb 命令进入 Ruby 交互式模式：

    1. $ irb
    2. >> content = "what is up, doc?"
    3. => "what is up, doc?"

    Git 以对象类型为起始内容构造一个文件头，本例中是一个 blob。然后添加一个空格，接着是数据内容的长度，最后是一个空字节 (null byte)：

    1. >> header = "blob #{content.length}\0"
    2. => "blob 16\000"

    Git 将文件头与原始数据内容拼接起来，并计算拼接后的新内容的 SHA-1 校验和。可以在 Ruby 中使用 require 语句导入 SHA1 digest 库，然后调用 Digest::SHA1.hexdigest() 方法计算字符串的 SHA-1 值：

    1. >> store = header + content
    2. => "blob 16\000what is up, doc?"
    3. >> require 'digest/sha1'
    4. => true
    5. >> sha1 = Digest::SHA1.hexdigest(store)
    6. => "bd9dbf5aae1a3862dd1526723246b20206e5fc37"

    Git 用 zlib 对数据内容进行压缩，在 Ruby 中可以用 zlib 库来实现。首先需要导入该库，然后用 Zlib::Deflate.deflate() 对数据进行压缩：

    1. >> require 'zlib'
    2. => true
    3. >> zlib_content = Zlib::Deflate.deflate(store)
    4. => "x\234K\312\311OR04c(\317H,Q\310,V(-\320QH\311O\266\a\000_\034\a\235"

    最后将用 zlib 压缩后的内容写入磁盘。需要指定保存对象的路径 (SHA-1 值的头两个字符作为子目录名称，剩余 38 个字符作为文件名保存至该子目录中)。在 Ruby 中，如果子目录不存在可以用 FileUtils.mkdir_p() 函数创建它。接着用 File.open 方法打开文件，并用 write() 方法将之前压缩的内容写入该文件：

    1. >> path = '.git/objects/' + sha1[0,2] + '/' + sha1[2,38]
    2. => ".git/objects/bd/9dbf5aae1a3862dd1526723246b20206e5fc37"
    3. >> require 'fileutils'
    4. => true
    5. >> FileUtils.mkdir_p(File.dirname(path))
    6. => ".git/objects/bd"
    7. >> File.open(path, 'w') { |f| f.write zlib_content }
    8. => 32

    这就行了 ── 你已经创建了一个正确的 blob 对象。所有的 Git 对象都以这种方式存储，惟一的区别是类型不同 ── 除了字符串 blob，文件头起始内容还可以是 commit 或 tree 。不过虽然 blob 几乎可以是任意内容，commit 和 tree 的数据却是有固定格式的。