Git-Distributed Version Control System part-3

Git-Distributed Version Control System part-3

Continue learning Git-Distributed Version Control System part-2 in this advanced guide. Explore branching, merging, and squashing with real-world Git workflow examples.

Git Reset Command 

git reset Command Explained (with examples)

The git reset command is used to undo changes in your Git repository. It moves the current HEAD (your current branch tip) to a specified state. You can use it to:

• Unstage files (remove from staging area)

• Move commits (undo commits)

• Change working directory contents (optional)

Syntax:

Modes of git reset:

---

 Examples:

1.  Unstage files (mixed is default):

This removes files from staging area, but keeps changes in working directory.

2.  Undo last commit (keep changes staged):

Use when you committed by mistake but want to keep your changes staged.

3. Undo last commit (unstage changes):

Undo the last commit and put the changes back to working directory (not staged).

4. Full reset – delete commit and changes:

Removes the last commit, staging, and working directory changes.

This is not reversible unless you have backup or reflog!

HEAD~1 meaning?

HEAD~1 = one commit before the current one.
You can also use commit hashes, like:

 Recover from git reset --hard (if needed):

If you made a mistake:

When to Use git reset

• Fix a bad commit

• Unstage or re-stage files

• Start over from a previous commit

Git Revert command

The git revert command is used to undo a previous commit by creating a new commit that reverses the changes made in the original one — without rewriting the commit history.

Syntax:

 Key Points:

• It does not delete the original commit.

• It creates a new commit with opposite changes.

• It is safe for shared/public branches like main or master.

• Useful when you want to undo a commit without rewriting history (unlike git reset).

 Example:

Revert a single commit:

This will create a new commit that undoes the changes of commit a1b2c3d.

 Interactive message (default):

When you run git revert, it opens your text editor to enter a message for the new revert commit:

You can also use --no-edit to skip this:

 Revert the last commit:

 Revert multiple commits (in sequence):

This reverts the last 3 commits (HEAD, HEAD1, HEAD2).

Conflict Handling:

If the commit you’re reverting has merge conflicts, Git will notify you and you’ll need to manually resolve them before completing the revert:

git revert vs git reset:

When to Use git revert:

• You want to undo changes without breaking collaboration.

• You’re working on a shared/public branch.

• You want a clear history of corrections.

Git – .gitignore file

What is .gitignore in Git?

The .gitignore file tells Git which files and folders to ignore – meaning Git won’t track, stage, or commit them to the repository.

Why is .gitignore used?

It helps avoid committing:

• Temporary files (e.g., .log, .tmp)

• Build output (e.g., /dist, /build)

• Sensitive information (e.g., .env)

• System/IDE files (e.g., .DS_Store, .vscode/)

Sample .gitignore file:

Important Notes:

• The .gitignore file is placed in the root directory of your Git project.

• If a file is already being tracked by Git, adding it to .gitignore won’t stop tracking it.

  • You must first remove it from staging:

    bash

    git rm --cached filename


How to create and use .gitignore:

1. Create a .gitignore file in the project’s root folder.

2. Add the patterns of files/folders you want Git to ignore.

3. Save and commit it:

   bash

    

   git add .gitignore
git commit -m "Add .gitignore file"


Bonus – Get Prebuilt Templates:

If you’re working on a specific language or framework (like Python, Node.js, Java, etc.), you can get ready-to-use .gitignore templates from:

Click Here

 Git – diff command

What is git diff?

The git diff command shows the difference between:

• files in your working directory and staging area

• or between commits

• or between branches

It helps you see what has changed before you commit or push.

Basic Syntax:

This shows the difference between your working directory and the staging area (index).

Common Use Cases of git diff:

Example Output:

• Lines prefixed with - are removed

• Lines prefixed with + are added

Visual Example:

Let’s say you changed a file named app.js but haven’t staged it yet. Running:

will show what’s different between the saved file and the current version in Git.

Helpful Tip:

Use this command before committing to review your changes and avoid mistakes.