Mastering Git: Essential Commands, Best Practices, and Pitfalls to Avoid

Photo by Yancy Min on Unsplash

Git is the backbone of modern software development. As a distributed version control system, it allows developers to track changes, collaborate seamlessly, and maintain a clean history of their projects. Whether you’re a beginner or a seasoned developer, understanding Git’s core commands and workflows is crucial. In this article, we’ll explore the most frequently used Git commands, provide practical examples, and share best practices to help you avoid common pitfalls.

What is Git?

Git is a free, open-source distributed version control system created by Linus Torvalds in 2005. Unlike centralized systems, every developer’s working copy of the code is a full-fledged repository, enabling offline work and faster operations. Git excels at:

• Tracking changes in files.
• Facilitating collaboration across teams.
• Managing branches for parallel development.
• Reverting to previous states of a project.

Essential Git Commands

1. git config

Purpose: Configure user details for commits.

# Set global username and email  
git config --global user.name "Your Name"  
git config --global user.email "your@email.com"

Example:

git config --global user.name "John Doe"  
git config --global user.email "john@doe.com"

2. git init

Purpose: Initialize a new Git repository.

git init [project-name]

Example:

mkdir my-project && cd my-project  
git init

3. git clone

Purpose: Clone an existing repository.

git clone [repository-url]

Example:

git clone https://github.com/roman-huliak/bunny.git

4. git branch

Purpose: Create, list, or delete branches.

# Create a branch  
git branch [branch-name]  

# Delete a branch  
git branch -d [branch-name]  

# List all branches  
git branch -a

Example:

git branch feature-login  
git branch -d old-feature

5. git checkout

Purpose: Switch branches or restore files.

# Switch to a branch  
git checkout [branch-name]  

# Create and switch to a new branch  
git checkout -b [new-branch]

Example:

git checkout main  
git checkout -b hotfix

6. git reset

Purpose: Undo changes by moving the HEAD pointer.

• --soft: Keep changes staged.
• --mixed (default): Unstage changes.
• --hard: Discard all changes.

Example:

# Undo the last commit but keep changes  
git reset --soft HEAD~1  

# Discard all changes in the last commit  
git reset --hard HEAD~1

7. git log

Purpose: View commit history.

# Compact log  
git log --oneline  

# Visualize branches  
git log --graph --oneline

Example:

git log --oneline -n 5  # Show last 5 commits

8. git add & git rm

Purpose: Stage files or remove them from tracking.

# Stage all changes  
git add .

# Remove a file  
git rm file.txt

Example:

git add index.html styles.css  
git rm old-image.jpg

9. git commit

Purpose: Save staged changes with a message.

git commit -m "Descriptive commit message"

Example:

git commit -m "feat(auth): Add user authentication feature"

Read more about Meaningful commit messages.

Conventional Commits: A Standardized Approach to Meaningful Commit Messages

10. git push

Purpose: Upload local commits to a remote repository.

git push [remote] [branch]

Example:

git push origin main

11. git pull

Purpose: Fetch and merge changes from a remote.

git pull [remote] [branch]

Example:

git pull origin develop

12. git fetch

Purpose: Download updates from a remote without merging.

git fetch [remote]

Example:

git fetch origin

Difference Between git fetch and git pull

13. git rebase

Purpose: Reapply commits on top of another branch (rewrites history).

git rebase [base-branch]

Example:

git checkout feature  
git rebase main

Warning: Avoid rebasing public branches shared with others!

Best Practices & Avoiding Pitfalls

1. Commit Early, Commit Often

• Do: Make small, atomic commits with clear messages.
• Avoid: Giant commits like “Fix everything.”

2. Use Branches Wisely

• Do: Create branches for new features or bug fixes.
• Avoid: Direct commits to main or develop.

3. Pull Before You Push

• Do: Always git pull before pushing to avoid conflicts.
• Avoid: Force-pushing (git push -f) unless necessary.

4. Rebase with Caution

• Do: Rebase local branches to keep history clean.
• Avoid: Rebasing branches others are using.

5. Leverage .gitignore

• Do: Exclude build files, logs, and environment configurations.
• Avoid: Committing sensitive data (passwords, API keys).

.gitkeep and .gitignore files: Real-World Examples

6. Test Before Committing

• Do: Verify changes work before committing.
• Avoid: Pushing untested code to shared branches.

7. Backup Work with Remote Repos

• Do: Push changes to a remote repository regularly.
• Avoid: Keeping critical work only locally.

Common Pitfalls & Solutions

Accidental git reset --hard:

• Use git reflog to recover lost commits.

Merge Conflicts:

• Resolve conflicts manually, then commit.

Force-Pushing Over Shared History:

• Communicate with your team before rewriting history.

Unintended Large Files:

• Use git rm --cached and update .gitignore.

Conclusion

Git is a powerful tool, but its complexity can lead to mistakes if not used carefully. By mastering core commands, adhering to best practices, and understanding potential pitfalls, you’ll streamline your workflow and collaborate effectively. Remember: When in doubt, test your changes, communicate with your team, and back up your work.

Happy coding! 🚀

Enjoyed this article? Let me know in the comments, and don’t forget to share it with your team!