We use git in our day to day life , we use various commands like git add , git commit , git push, etc.

But very few of us know what actually happens internally, Git is used to help track the changes made to the project.

git basically helps us take a screenshot of the file/project whenever we want using the git commit command.

git is like a mini database that saves screenshots of your project.

It has mainly 3 areas:

1.Working Directory — It contains the actual files

2.Staging Area — It contain files that are ready to be saved

3.Repository — Git’s database

Understanding the .git Folder

Whenever we are working on a project , whatever we are doing on it , nothing is getting saved like all the changes we do to it, if we want to go back and look at the previous code we don’t know anything because nobody kept the track of changes , But what if i say there is a way to keep track of all the changes , versions , data and files of the folder , yes There is a way , It is by using the git software.

But a project folder does not use git by default , we first need to do something that will connect our project to git software…..

How do we do it?

We do git init

The git init command create a .git/ folder inside the main project folder.

This folder is the brain , memory , database of Git.

Structure of .git Folder

.git/ Folder contains

• all the data like commits, files and history.

• it contains the staging area.

• The current branch you’re on (HEAD of the folder)

• Branch pointers, etc.

Git Objects: Blob, Tree, Commit

In Git , there are only 3 types of objects - blob , tree and commit.

Blob

Blob stores the raw data inside a file. It does not store any permissions , file name , etc.

if a file app.js contains — console.log("Hello")

Git will store this text as a git object

If you change this file to — console.log("Hello world")

Git makes a new blob , because every git contains a fingerprint.

Tree

A tree represents a folder. It contains a folder snapshot.

project/

── app.js → Blob A

── app.css/ → Blob B

—-feat/ —>Tree B

Commit

A commit stores :

-how a project looks

-previous snapshot of project

-author / who did it

-time / when the author did it

How Git Tracks Changes

Git does not track changes like 5 lines changed, etc.

It takes a full snapshot of the current project every time you commit.

So whenever you commit , git takes a full photo of your project

So if git is taking full photo of your project every time would it not waste space??

No IT WON’T

Suppose you have 3 files in your project and you made some changes to one file rest are same ,

Then , initially :

Git stores 3 blobs:

You change ONLY app.js

Now you commit again.

Git does:

Git does NOT duplicate unchanged files.

Only changed file = new object.

How Git Detects a Change

Git checks file content, not filename.

It calculates a hash (fingerprint).

So , Git tracks:

File content
Folder structure
Snapshots over time