• 10.4 Git 内部原理 - 包文件
    • 包文件

    10.4 Git 内部原理 - 包文件

    包文件

    让我们重新回到示例 Git 版本库的对象数据库。目前为止，可以看到有 11 个对象——4 个数据对象、3 个树对象、3 个提交对象和 1 个标签对象：

    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/95/85191f37f7b0fb9444f35a9bf50de191beadc2 # tag
    8. .git/objects/ca/c0cab538b970a37ea1e769cbbde608743bc96d # commit 2
    9. .git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4 # 'test content'
    10. .git/objects/d8/329fc1cc938780ffdd9f94e0d364e0ea74f579 # tree 1
    11. .git/objects/fa/49b077972391ad58037050f2a75f74e3671e92 # new.txt
    12. .git/objects/fd/f4fc3344e67ab068f836878b6c4951e3b15f3d # commit 1

    Git 使用 zlib 压缩这些文件的内容，而且我们并没有存储太多东西，所以上文中的文件一共只占用了 925 字节。接下来，我们会指引你添加一些大文件到版本库中，以此展示 Git 的一个很有趣的功能。为了便于展示，我们要把之前在 Grit 库中用到过的 repo.rb 文件添加进来——这是一个大小约为 22K 的源代码文件：

    1. $ curl https://raw.githubusercontent.com/mojombo/grit/master/lib/grit/repo.rb > repo.rb
    2. $ git add repo.rb
    3. $ git commit -m 'added repo.rb'
    4. [master 484a592] added repo.rb
    5.  3 files changed, 709 insertions(+), 2 deletions(-)
    6.  delete mode 100644 bak/test.txt
    7.  create mode 100644 repo.rb
    8.  rewrite test.txt (100%)

    如果你查看生成的树对象，可以看到 repo.rb 文件对应的数据对象的 SHA-1 值：

    1. $ git cat-file -p master^{tree}
    2. 100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
    3. 100644 blob 033b4468fa6b2a9547a70d88d1bbe8bf3f9ed0d5      repo.rb
    4. 100644 blob e3f094f522629ae358806b17daf78246c27c007b      test.txt

    接下来你可以使用 git cat-file 命令查看这个对象有多大：

    1. $ git cat-file -s 033b4468fa6b2a9547a70d88d1bbe8bf3f9ed0d5
    2. 22044

    现在，稍微修改这个文件，然后看看会发生什么：

    1. $ echo '# testing' >> repo.rb
    2. $ git commit -am 'modified repo a bit'
    3. [master 2431da6] modified repo.rb a bit
    4.  1 file changed, 1 insertion(+)

    查看这个提交生成的树对象，你会看到一些有趣的东西：

    1. $ git cat-file -p master^{tree}
    2. 100644 blob fa49b077972391ad58037050f2a75f74e3671e92      new.txt
    3. 100644 blob b042a60ef7dff760008df33cee372b945b6e884e      repo.rb
    4. 100644 blob e3f094f522629ae358806b17daf78246c27c007b      test.txt

    repo.rb 对应一个与之前完全不同的数据对象，这意味着，虽然你只是在一个 400 行的文件后面加入一行新内容，Git 也会用一个全新的对象来存储新的文件内容：

    1. $ git cat-file -s b042a60ef7dff760008df33cee372b945b6e884e
    2. 22054

    你的磁盘上现在有两个几乎完全相同、大小均为 22K 的对象。如果 Git 只完整保存其中一个，再保存另一个对象与之前版本的差异内容，岂不更好？

    事实上 Git 可以那样做。Git 最初向磁盘中存储对象时所使用的格式被称为“松散（loose）”对象格式。但是，Git 会时不时地将多个这些对象打包成一个称为“包文件（packfile）”的二进制文件，以节省空间和提高效率。当版本库中有太多的松散对象，或者你手动执行 git gc 命令，或者你向远程服务器执行推送时，Git 都会这样做。要看到打包过程，你可以手动执行 git gc 命令让 Git 对对象进行打包：

    1. $ git gc
    2. Counting objects: 18, done.
    3. Delta compression using up to 8 threads.
    4. Compressing objects: 100% (14/14), done.
    5. Writing objects: 100% (18/18), done.
    6. Total 18 (delta 3), reused 0 (delta 0)

    这个时候再查看 objects 目录，你会发现大部分的对象都不见了，与此同时出现了一对新文件：

    1. $ find .git/objects -type f
    2. .git/objects/bd/9dbf5aae1a3862dd1526723246b20206e5fc37
    3. .git/objects/d6/70460b4b4aece5915caf5c68d12f560a9fe3e4
    4. .git/objects/info/packs
    5. .git/objects/pack/pack-978e03944f5c581011e6998cd0e9e30000905586.idx
    6. .git/objects/pack/pack-978e03944f5c581011e6998cd0e9e30000905586.pack

    仍保留着的几个对象是未被任何提交记录引用的数据对象——在此例中是你之前创建的“what is up, doc?”和“test content”这两个示例数据对象。因为你从没将它们添加至任何提交记录中，所以 Git 认为它们是悬空（dangling）的，不会将它们打包进新生成的包文件中。

    剩下的文件是新创建的包文件和一个索引。包文件包含了刚才从文件系统中移除的所有对象的内容。索引文件包含了包文件的偏移信息，我们通过索引文件就可以快速定位任意一个指定对象。有意思的是运行 gc 命令前磁盘上的对象大小约为 22K，而这个新生成的包文件大小仅有 7K。通过打包对象减少了 ⅔ 的磁盘占用空间。

    Git 是如何做到这点的？Git 打包对象时，会查找命名及大小相近的文件，并只保存文件不同版本之间的差异内容。你可以查看包文件，观察它是如何节省空间的。git verify-pack 这个底层命令可以让你查看已打包的内容：

    1. $ git verify-pack -v .git/objects/pack/pack-978e03944f5c581011e6998cd0e9e30000905586.idx
    2. 2431da676938450a4d72e260db3bf7b0f587bbc1 commit 223 155 12
    3. 69bcdaff5328278ab1c0812ce0e07fa7d26a96d7 commit 214 152 167
    4. 80d02664cb23ed55b226516648c7ad5d0a3deb90 commit 214 145 319
    5. 43168a18b7613d1281e5560855a83eb8fde3d687 commit 213 146 464
    6. 092917823486a802e94d727c820a9024e14a1fc2 commit 214 146 610
    7. 702470739ce72005e2edff522fde85d52a65df9b commit 165 118 756
    8. d368d0ac0678cbe6cce505be58126d3526706e54 tag    130 122 874
    9. fe879577cb8cffcdf25441725141e310dd7d239b tree   136 136 996
    10. d8329fc1cc938780ffdd9f94e0d364e0ea74f579 tree   36 46 1132
    11. deef2e1b793907545e50a2ea2ddb5ba6c58c4506 tree   136 136 1178
    12. d982c7cb2c2a972ee391a85da481fc1f9127a01d tree   6 17 1314 1 \
    13.   deef2e1b793907545e50a2ea2ddb5ba6c58c4506
    14. 3c4e9cd789d88d8d89c1073707c3585e41b0e614 tree   8 19 1331 1 \
    15.   deef2e1b793907545e50a2ea2ddb5ba6c58c4506
    16. 0155eb4229851634a0f03eb265b69f5a2d56f341 tree   71 76 1350
    17. 83baae61804e65cc73a7201a7252750c76066a30 blob   10 19 1426
    18. fa49b077972391ad58037050f2a75f74e3671e92 blob   9 18 1445
    19. b042a60ef7dff760008df33cee372b945b6e884e blob   22054 5799 1463
    20. 033b4468fa6b2a9547a70d88d1bbe8bf3f9ed0d5 blob   9 20 7262 1 \
    21.   b042a60ef7dff760008df33cee372b945b6e884e
    22. 1f7a7a472abf3dd9643fd615f6da379c4acb3e3a blob   10 19 7282
    23. non delta: 15 objects
    24. chain length = 1: 3 objects
    25. .git/objects/pack/pack-978e03944f5c581011e6998cd0e9e30000905586.pack: ok

    此处，033b4 这个数据对象（即 repo.rb 文件的第一个版本，如果你还记得的话）引用了数据对象 b042a，即该文件的第二个版本。命令输出内容的第三列显示的是各个对象在包文件中的大小，可以看到 b042a 占用了 22K 空间，而 033b4 仅占用 9 字节。同样有趣的地方在于，第二个版本完整保存了文件内容，而原始的版本反而是以差异方式保存的——这是因为大部分情况下需要快速访问文件的最新版本。

    最妙之处是你可以随时重新打包。Git 时常会自动对仓库进行重新打包以节省空间。当然你也可以随时手动执行 git gc 命令来这么做。

    prev | next

    原文: https://git-scm.com/book/zh/v2/Git-%E5%86%85%E9%83%A8%E5%8E%9F%E7%90%86-%E5%8C%85%E6%96%87%E4%BB%B6