Git has become an essential tool for programmers and is widely used in the software industry. Whether you’re working on a solo project or collaborating with a team, Git helps you track changes, manage versions, and streamline your development workflow. Most programmers are well-versed in common Git commands like commit, push, and pull. However, there are several underrated commands that can significantly boost your productivity and Git proficiency.
Today, I’m sharing 8 underrated Git commands that will make you more efficient, help you debug better, and keep your repository cleaner. Let’s dive in!
Note: To get the most out of this article, you should have a basic understanding of Git (like staging changes and making commits). Ready? Let’s level up your Git game!
You’ve already nailed down the fundamental commands:
git clone: Your go-to for creating a local copy of a remote repository.git branch: Essential for managing parallel lines of development.git checkout: How you navigate between different branches or commits.git status: Your window into the current state of your working directory and staging area.git add: The command that stages your changes for the next commit.git commit: Recording snapshots of your changes with descriptive messages.git push: Sharing your local commits with a remote repository.git pull: Fetching and integrating changes from a remote repository.
These are the bread and butter, no doubt. But now, let’s explore the hidden gems that can truly enhance your Git workflow!
1. git stash – Your Emergency Save Button
Ever been in the middle of making changes when you suddenly need to switch branches or pull in urgent updates? You don’t want to commit half-finished work! That’s where git stash comes to the rescue. It takes your uncommitted changes (both staged and unstaged) and saves them temporarily, giving you a clean working directory.
How to use it:
git stash: Saves your current changes. You can even add a descriptive message:git stash save "WIP on feature X"git stash list: Shows you a list of your stashed changes.git stash apply: Reapplies the most recent stash. You can also apply a specific stash using its identifier (e.g.,git stash apply stash@{2}).git stash pop: Applies the most recent stash and then removes it from the stash list.git stash drop <stash_id>: Removes a specific stash.git stash clear: Removes all stashed changes (use with caution!).
My Trick: I often use git stash push -u which also stashes untracked files. Super handy when you’ve created new files you haven’t explicitly added yet!
2. git log --oneline – Concise Commit History
The regular git log can be quite verbose. When you just need a quick overview of the commit history, git log --oneline is your best friend. It displays each commit on a single line, showing the abbreviated commit hash and the commit message.
How to use it:
git log --oneline: Displays a condensed commit history.
Bonus Tip: Combine it with --graph to see the branch structure visually: git log --oneline --graph. It’s a fantastic way to understand how branches have diverged and merged.
3. git reflog – Your Git Time Machine
Ever accidentally deleted a branch or made a commit you immediately regretted? git reflog is your safety net! It keeps track of every change to the HEAD (the pointer to your current commit) and branch references. This includes branch creations, deletions, merges, and even resets. It’s like a detailed history of your Git actions.
How to use it:
git reflog: Shows the reflog. Each entry has an index (likeHEAD@{2}).git checkout <reflog_entry>: You can use the reflog entry index to go back to a specific point in your Git history. For example,git checkout HEAD@{2}will take you back to the state of your repository two HEAD movements ago.
My Thought: I’ve used git reflog countless times to recover from accidental git reset --hard commands. It’s a lifesaver!
4. git bisect – Debugging with Binary Search
When a bug creeps into your codebase, and you’re not sure which commit introduced it, git bisect can be a game-changer. It helps you perform a binary search through your commit history to pinpoint the exact commit that caused the issue.
How to use it:
git bisect start: Initiates the bisecting process.git bisect bad: Marks your current commit as containing the bug.git bisect good <good_commit>: Marks a known good commit (usually an older one).- Git will then check out a commit in the middle of the range. You test your code at this commit.
git bisect goodorgit bisect bad: Based on your testing, you tell Git whether this commit is good or bad.- Git continues this process, narrowing down the range of potentially problematic commits until it identifies the culprit.
git bisect reset: Exits the bisecting process and returns you to your original branch.
Engaging Tip: Imagine trying to find a single faulty lightbulb in a string of hundreds. git bisect is like systematically checking half the remaining bulbs each time, quickly leading you to the broken one!
5. git blame – Who Wrote That?
Ever wondered who introduced a specific line of code and when? git blame (sometimes also known as git annotate) shows you, for each line in a file, the last commit that modified that line and the author of that commit. This can be incredibly helpful for understanding the context and history of a particular piece of code.
How to use it:
git blame <file>: Shows the blame information for the specified file.
My Take: While it can be tempting to use git blame to point fingers, I find it most useful for understanding the evolution of the codebase and identifying who might have the most context on a particular section.
6. git cherry-pick – Selective Commit Integration
Sometimes you need to bring over a specific commit from one branch to another without merging the entire branch. git cherry-pick allows you to do just that. It takes the changes introduced by a single commit and applies them to your current branch.
How to use it:
git checkout <target_branch>: Switch to the branch where you want to apply the commit.git cherry-pick <commit_hash>: Cherry-picks the specified commit.
Important Note: Cherry-picking can sometimes lead to duplicate commits in your history, so use it judiciously.
7. git rebase -i HEAD~n – Interactive History Editing
git rebase is often used to integrate changes from one branch into another, but the -i (interactive) flag opens up a world of possibilities for rewriting your commit history. You can reorder commits, squash multiple commits into one, edit commit messages, or even drop commits entirely.
How to use it:
git rebase -i HEAD~n: Replacenwith the number of previous commits you want to edit. This will open an editor with a list of your commits.- In the editor, you can change the actions for each commit:
pick: Use the commit as is.squash: Combine this commit with the previous one.fixup: Combine this commit with the previous one, discarding this commit’s message.reword: Edit the commit message.drop: Remove the commit.
- Save and close the editor. Git will then perform the actions you specified.
Word of Caution: Rewriting history on shared branches can cause problems for your collaborators, so it’s generally best to do this on local branches before pushing.
8. git shortlog – Summarized Commit Statistics
Want a quick overview of the contributions to your project? git shortlog summarizes the commit history, grouping commits by author and showing the number of commits each author has made.
How to use it:
git shortlog: Shows a summary of commits by author.git shortlog -sn: Sorts the output by the number of commits.
My Insight: This is a great command for getting a high-level view of team activity and individual contributions.
Level Up Your Git Game!
Mastering these eight underrated Git commands can significantly enhance your workflow, make debugging easier, and give you greater control over your project’s history. Don’t just stick to the basics – explore the power that Git offers!
I’ll definitely be sharing more useful Git tips and tricks in future posts, so make sure to bookmark this page and check back for more!
Which of these commands are you most excited to try? Let me know in the comments below!
Love this, Bushra! Git mastery is key
Yes Natasha, Totally agree! Git mastery can really boost productivity. Glad you liked the post!
Thanks for sharing these hidden gems, Bushra! These Git commands are exactly what I needed to level up my workflow. Appreciate the insights
Edwin, Glad you found the Git commands helpful! Thanks for your kind words, happy coding!
Great post Bushra! I’ve been using Git for a while, but I learned some new tricks here. The underrated commands you mentioned are definitely going on my favorites list
Thank you so much! I’m glad you found the explanation helpful. Keep learning!