Introduction to the Git Object Model

The Git object model is the core of the Git version control system, defining the fundamental way data is stored and manipulated. Understanding the Git object model helps in mastering Git's inner workings, enabling more efficient version management.

Components of the Git Object Model

The Git object model primarily consists of four core objects: blob, tree, commit, and tag. These objects are uniquely identified by SHA-1 hashes and stored in Git's .git/objects directory.

Blob Objects

A blob (binary large object) stores file content. Git does not track filenames, only file content. For example, a file named hello.txt with the content Hello, Git! would have a corresponding blob object as follows:

// Assuming the file content is "Hello, Git!"
const content = "Hello, Git!";
const blobHeader = `blob ${content.length}\0`;
const blobData = blobHeader + content;
const sha1 = require('crypto').createHash('sha1').update(blobData).digest('hex');
console.log(sha1); // Outputs the SHA-1 hash of the blob

Tree Objects

A tree object represents a directory structure, containing filenames, file permissions, and the SHA-1 hashes of corresponding blobs or subtrees. For example, a tree object for a directory containing hello.txt might look like this:

100644 blob 2d832d9044c698081e59c322d5a2a459da546469    hello.txt

Commit Objects

A commit object records a project snapshot, including the author, committer, commit message, and the hash of the tree object it points to. For example:

tree 92b8b6ffb5f1d925a4f5e0f0e8b5b8e8e8e8e8e8
parent 2d832d9044c698081e59c322d5a2a459da546469
author John Doe <john@example.com> 1625097600 +0800
committer John Doe <john@example.com> 1625097600 +0800

Initial commit

Tag Objects

A tag object marks a specific commit, typically used for version releases. It includes the tag name, tag message, and the hash of the commit it points to. For example:

object 2d832d9044c698081e59c322d5a2a459da546469
type commit
tag v1.0.0
tagger John Doe <john@example.com> 1625097600 +0800

Release version 1.0.0

Relationships Between Git Objects

Git objects reference each other via their hashes, forming a directed acyclic graph (DAG). For example:

• A commit object points to a tree object.
• A tree object can contain multiple blob objects or other tree objects.
• A tag object points to a commit object.

This design enables Git to efficiently store and retrieve historical records.

Storage of Git Objects

Git objects are stored in the .git/objects directory, with the first two characters of the hash as the directory name and the remaining 38 characters as the filename. For example, an object with the hash 2d832d9044c698081e59c322d5a2a459da546469 is stored in 2d/832d9044c698081e59c322d5a2a459da546469.

Example: Manually Creating a Git Object

Here’s an example of manually creating a Git object:

const fs = require('fs');
const crypto = require('crypto');

function createBlob(content) {
  const header = `blob ${content.length}\0`;
  const data = header + content;
  const sha1 = crypto.createHash('sha1').update(data).digest('hex');
  const dir = `.git/objects/${sha1.substring(0, 2)}`;
  const file = `${dir}/${sha1.substring(2)}`;
  
  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
  const zlib = require('zlib');
  const compressed = zlib.deflateSync(data);
  fs.writeFileSync(file, compressed);
  return sha1;
}

const blobSha = createBlob('Hello, Git!');
console.log(`Blob SHA-1: ${blobSha}`);

Compression and Optimization of Git Objects

Git uses zlib compression to store objects, reducing disk space usage. Additionally, Git employs the packfile mechanism to bundle multiple objects together, further optimizing storage efficiency.

References and Branches

Git references (e.g., branches, HEAD) are pointers to commit objects. For example, refs/heads/main is a reference pointing to the latest commit. Here’s an example of inspecting a reference:

const head = fs.readFileSync('.git/HEAD', 'utf-8').trim();
if (head.startsWith('ref: ')) {
  const ref = head.substring(5);
  const commitSha = fs.readFileSync(`.git/${ref}`, 'utf-8').trim();
  console.log(`Current branch: ${ref}, commit: ${commitSha}`);
}

Advantages of the Object Model

The Git object model offers the following advantages:

1. Content Addressing: Objects are uniquely identified by their hashes, ensuring data integrity.
2. Efficient Storage: Duplicate content is stored only once, saving space.
3. Historical Tracking: The chain-like structure of commit objects makes it easy to trace history.

Practical Applications

Understanding the Git object model helps solve problems such as:

• Recovering lost commits or files.
• Analyzing repository history.
• Manually repairing corrupted Git repositories.

For example, you can inspect an object's content using git cat-file -p <hash>:

git cat-file -p 2d832d9044c698081e59c322d5a2a459da546469