Git is essentially a persistent map of Keys and Values. Values are your file contents, and the Keys are unique 40-character strings (a SHA-1 hash) generated based on that content. When you save a file in Git, it doesn't care about the filename initially; it only cares about the data. If two files have the same content, Git stores only one copy of that data internally for saving space.

Understanding the .git Folder

When you run git initGit creates a hidden directory called .git. This is where the entire history and "soul" of your project lives. If you delete this folder, your project becomes just a regular set of files with no history.

Key components inside .git folder:

• objects/: This stores all your actual file content (blobs), directory structures (trees), and commit metadata. We can say this folder acts like a database.

• refs/: Stores pointers to commit objects (like where main or feature-x currently point).

• HEAD: A file that tells Git which branch or commit you are currently working on.

• index: It’s a binary file that lists what will go into your next commit. Also known as the Staging Area.

Git Objects: Blob, Tree, Commit

Everything in the objects/ folder falls into one of these three categories: Blob (Binary Large Object),Tree, and Commit.

• Blob (Binary Large Object): → A Blob stores only the file content. It does not store the filename, the date, or the permissions. For example, if chai-code.txt it contains "Kaise hai ap sabhi", Git hashes "Kaise hai ap sabhi" and stores it as a blob.

• Tree: → A Tree represents a directory. It acts like a list that maps filenames to their corresponding Blobs (for files) or other Trees (for subdirectories). This is where the "filename" information is finally stored.

• Commit: → A Commit is a screenshot of the project at a point in time. It contains:

  1. A pointer to the root Tree (the top-level folder)

  2. The author and committer information.

  3. A message or a description

  4. A pointer to the parent commit(s), which creates the chain of history.

How Git Tracks Changes?

Git takes screenshots for tracking the changes.

1. Staging: → When you run git add Git creates a Blob for the file content and updates the index (staging area).

2. Committing: → When you run git commit, Git wraps the current index into Tree objects and creates a Commit object that points to that top-level Tree.

3. Efficiency: → If a file hasn't changed between commit A and commit B, Git does not create a new Blob. The Tree in commit B simply points to the same SHA-1 hash/Blob that commit A used.