Git is a version control system that is used to keep track of changes made to files and directories over time. At its core, Git uses a set of objects to store and manage this information. In this article, we’ll take a closer look at these objects and how they work.

The Three Types of Git Objects

Git uses three types of objects to store and manage information: blobs, trees, and commits. Each type of object serves a specific purpose and is used in different ways.

Blobs

A blob, or binary large object, is used to store the contents of a file. When you make changes to a file and commit them, the new version of the file is stored as a new blob. Blobs are identified by a unique SHA-1 hash, which is a 40-character string of letters and numbers.

For example, let’s say you have a file called “example.txt” that contains the text “Hello, world!”. When you first commit this file to your Git repository, a blob is created with the contents of the file. The SHA-1 hash of this blob might be something like “6d9f3a1c902e9a48b8c9b6f973a9bbd1f2f1a0a2”.

Trees

A tree is used to store the directory structure of your repository. Each tree object represents a directory and contains a list of blobs and other tree objects that are inside that directory. Like blobs, trees are identified by a unique SHA-1 hash.

For example, let’s say you have a directory called “example” that contains two files: “example.txt” and “example2.txt”. When you commit this directory to your Git repository, a tree object is created that represents the directory. This tree object contains two entries, one for each file, that point to the corresponding blob objects for those files. The SHA-1 hash of this tree might be something like “8c9b6f973a9bbd1f2f1a0a26d9f3a1c902e9a48b”.

Commits

A commit is used to represent a specific point in the history of your repository. Each commit object contains information about the changes that were made in that commit, including the SHA-1 hashes of the tree and blob objects that were affected. Commits also contain metadata such as the author and date of the commit, as well as a message that describes the changes.

For example, let’s say you make changes to “example.txt” and commit them to your Git repository. A new blob object is created with the updated contents of the file, and a new commit object is created that contains the SHA-1 hash of this new blob and the metadata for the commit. The SHA-1 hash of this commit might be something like “902e9a48b8c9b6f973a9bbd1f2f1a0a26d9f3a1c”.

How Git Objects Work Together

Now that we’ve looked at the three types of Git objects, let’s see how they work together. When you make changes to a file and commit them, the following steps happen:

1. The file is read and its contents are stored in a new blob object.
2. The SHA-1 hash of the new blob is calculated and used to create a new tree object that represents the directory containing the file.
3. The SHA-1 hash of the new tree is used to create a new commit object that represents the commit and contains the metadata for the commit as well as the SHA-1 hash of the new tree.

This process is repeated every time you make changes to a file and commit them. Each new commit object points to the tree object that represents the current state of the repository, and each tree object points to the blobs that contain the contents of the files.

In this way, Git is able to keep track of the entire history of your repository, with each commit representing a snapshot of the repository at a specific point in time. You can use Git commands like “git log” and “git diff” to view the history and compare different versions of your files.

Git also uses these objects to handle branching and merging. When you create a new branch, Git creates a new commit object that points to the same tree object as the commit you based the branch off of. As you make changes to the files in the new branch, new blobs and trees are created, and new commit objects are added to the branch’s history.

When you merge two branches, Git compares the commit objects for each branch and creates a new commit object that merges the changes from both branches. This new commit object points to a new tree object that represents the combined state of the repository after the merge.

Conclusion

In conclusion, Git uses a powerful set of objects to store and manage the information in your repository. Understanding how these objects work and how they interact with each other is essential for understanding how Git works and how to use it effectively.