10 insanely useful git commands for common git tasks

There’s a git command for that

Git commands aren’t always intuitive. If they were, we would have these 10 commands at our disposal. They would be super useful for accomplishing common tasks like creating or renaming a git branch, removing files, and undoing changes.

For each git command in our wishlist, we’ll show you the commands that actually exist and you can use to accomplish the same tasks. If you’re still learning Git, this list reads like a tutorial and is worth keeping as a cheatsheet.

Git commands on the wish-list:

• # 1 – git create branch
• # 2 – git force pull
• # 3 – git remove untracked files
• # 4 – git unstage
• # 5 – git undo merge
• # 6 – git remove file
• # 7 – git uncommit
• # 8 – git diff between branches
• # 9 – git delete tag
• # 10 – git rename branch

1. git create branch: create a new branch with git checkout

The fastest way to create a new branch is to actually do it from the git terminal. This way you don’t have to use GitHub UI, for example, if you use GitHub for version control. This command actually exists in git, only in a different name – `$ git checkout`.

How to create a branch with git checkout

One-line command: `$ git checkout -b <branch-name> master`

  
-> commit-test git:(master) $ git checkout -b feature-branch master
-> commit-test git:(feature-branch) $

Git tip: just like with commit messages, having a naming convention for git branches is a good best practice to adopt.

2. git force pull: overwrite local with git pull

You find out you’ve made changes that seemingly conflict with the upstream changes. At this point, you decide to overwrite your changes instead of keeping them, so you do a `$ git pull` and you get this error message:

  
-> commit-test git:(master) $ git pull
Updating db40e41..2958dc6
error: Your local changes to the following files would be overwritten by merge:
       README.md
hint:  Please, commit your changes before merging.
fatal: Exiting because of unfinished merge.

The problem is that you don’t want to commit your changes, you want to overwrite them!

How to overwrite local changes with git pull

1. Stash local changes: `$ git stash`
2. Pull changes from remote: `$ git pull`

  
-> commit-test git:(master) $ git stash
Updating db40e41..2958dc6
Saved working directory and index state WIP on main: d8fde76 fix(API): remove ‘test’ end-point
-> commit-test git:(master) $ git pull
Auto-merging README.md
Merge made by the ‘recurive’ strategy.
README.md      | 1 +
ENDPOINT.js    | 3 ++-
2 files changes, 3 insertions(+), 1 deletions(-)

Git tip: if you want to retrieve your changes just do: `$ git stash apply`

3. git remove untracked files: delete untracked files from working tree

When having unnecessary files and dirs in your own local copy of a repository, and you want to delete those files, in opposed to just ignore them (with .gitignore), you can use git clean to remove all files which are not tracked by git.

How to remove untracked files and dirs

1. Start with a dry-run to see what will be deleted: `$ git clean -n -d`
2. After you are sure, run the git clean command with -f flag: `$ git clean -f -d`
   

  
-> commit-test git:(master) $ git clean -n -d
Would remove dontTrackDir/untracked_file1.py
Would remove untracked_file2.py
-> commit-test git:(master) $ git clean -f -d
Removing dontTrackDir/untracked_file1.py
Removing untracked_file2.py

Git tip: instead of untracking files, a good practice is to prevent those files from being tracked in the first place by using .gitignore file.

4. git unstage: unstage file(s) from index

When you’re adding files ($ git add) to the working tree, you are adding them to the staging area, meaning you are staging them. If you want Git to stop tracking specific files on the working tree, you need to remove them from your stage files (.git/index).

How to unstage file(s) from index

• Keep the file but remove it from the index: `$ git rm --cached <file-name>`

  
-> commit-test git:(master) $ git rm –cached unstageMe.js
rm unstageMe.js

• To leave the entire working tree untouched, unstage all files (clear your index): `$ git reset`

  
-> commit-test git:(master) $ git reset
rm unstageMe.js

Git tip: you can also untrack files which already added to git repository based on .gitignore.

5. git undo merge: abort (cancel) a merge after it happened

Sometimes you get in a situation (we’ve all been there) where you merged branches and realize you need to undo the merge because you don’t want to release the code you just merged.

How to abort (cancel) a merge and maintain all committed history

1. Checkout to the master branch: `$ git checkout master`
2. Run git log and get the id of the merge commit: `$ git log --oneline`
3. Revert merge by commit id: `$ git revert -m 1 <merge-commit-id>`
4. Commit the revert and push changes to the remote repo. You can start putting on your poker face and pretend “nothing’s happened”.

  
-> commit-test git:(master) $ log –oneline
812d761 Merge pull request #524 from datreeio/DAT-1332-resolve-installation-id
b06dee0 feat: added installation event support
8471b2b fix: get organization details from repository object
-> commit-test git:(master) $ revert -m 1 812d761
Revert “Merge pull request #524 from datreeio/DAT-1332-resolve-installation-id”
[master 75b85db] Revert “Merge pull request #524 from datreeio/DAT-1332-resolve-installation-id”
1 file changed, 1 deletion(-)
-> commit-test git:(master) $ git commit -m "revert merge #524"
-> commit-test git:(master) $ git push

Git tip: instead of reverting merge, working with pull requests and setting up or improving your code review process can lower the possibility of a faulty merge.

6. git remove file: remove file(s) from a commit on remote

You wish to delete a file (or files) on remote, maybe because it is deprecated or because this file not supposed to be there in the first place. So, you wonder, what is the protocol to delete files from a remote git repository?

How to remove file(s) from commit

1. Remove your file(s): `$ git rm <file-A> <file-B> <file-C>`
2. Commit your changes: `$ git commit -m "removing files"`
3. Push your changes to git: `$ git push`

  
-> commit-test git:(delete-files) $ git rm deleteMe.js
rm ‘deleteMe.js’
-> commit-test git:(delete-files) $ git commit -m "removing files"
[delete-files 75e998e] removing files
1 file changed, 2 deletions(-)
delete mode 100644 deleteMe.js
-> commit-test git:(delete-files) $ git push

Git tip: when a file is removed from Git, it doesn’t mean it is removed from history. The file will keep “living” in the repository history until the file will be completely deleted.

7. git uncommit: undo the last commit

You made a commit but now you regret it. Maybe you committed secrets by accident – not a good idea – or maybe you want to add more tests to your code changes. These are all legit reasons to undo your last commit.

How to uncommit (undo) the last commit

• To keep the changes from the commit you want to undo: `$ git reset --soft HEAD^`
• To destroy the changes from the commit you want to undo: `$ git reset --hard HEAD^`

-> commit-test git:(undo-commit) $ git commit -m "I will regret this commit"
[undo-commit a7d8ed4] I will regret this commit
1 file changed, 1 insertion(+)
-> commit-test git:(undo-commit) $ git reset –soft HEAD^
-> commit-test git:(undo-commit) $ git status
On branch undo-commit
Changes to be committed:
(use “git reset HEAD <file>…” to unstage)

    modified: README.md

Git tip: git pre-commit hook is a built-in feature that lets you define scripts that will run automatically before each commit. Use it to reduce the need to cancel commits.

8. git diff between branches

When you are working with multiple git branches, it’s important to be able to compare and contrast the differences between two different branches on the same repository. You can do this using the $ git diff command.

How to get the diff between two branches

• Find the diff between the tips of the two branches: `$ git diff branch_1..branch_2`
• Produce the diff between two branches from common ancestor commit: `$ git diff branch_1...branch_2`
• Comparing files between branches: `$ git diff branch1:file branch2:file`

  
-> commit-test git:(diff-me) $ git diff master..diff-me
diff –git a/README.md b/README.md
index b74512d..da1e423 100644
— a/README.md
+++ b/README.md
@@ -1,2 +1,3 @@
# commit-test
-Text on “master” branch
+Text on “diff-me” branch

Git tip: diff-so-fancy is a great open source solution to make your diffs human readable.

9. git delete tag: remove a tag from branch

In the case of a “buggy” release, you probably don’t want someone to accidentally use the release linked to this tag. The best solution is to delete the tag and remove the connection between a release and its co-related tag.

How to delete tag by removing it from branch

1. If you have a remote tag <tag-name> to delete, and your remote is origin, then simply: `$ git push origin :refs/tags/<tag-name>`
2. If you also need to delete the tag locally: `$ git tag -d <tag-name>`

  
-> commit-test git:(delete-tag) $ git push origin :refs/tags/v1.0.0
To github.com:datreeio/commit-test.git
– [deleted]         v1.0.0
-> commit-test git:(delete-tag) $ git tag -d v1.0.0
Deleted tag ‘v1.0.0’ (was af4d0ea)

Git tip: not sure when or why to use tags? Read here to learn more (TL;DR: automatic releasing)

10. git rename branch: change branch name

As I mentioned, having a branch naming convention a good practice and should be adopted as part of your coding standards, and it is especially useful in supporting automation of git workflows. But what to do when you find out your branch name is not aligned with the convention, after already pushing code to the branch? Don’t worry, you can still rename your branch.

How to rename branch name after it was created

1. Checkout to the branch you need to rename: `$ git checkout <old-name>`
2. Rename branch name locally: `$ git branch -m <new-name>`
3. Delete old branch from remote: `$ git push origin :<old-name> <new-name>`
4. Reset the upstream branch for the new branch name: `$ git push origin -u <new-name>`

  
-> commit-test git:(old-name) $ git branch -m new-name
-> commit-test git:(new-name) $ git push origin :old-name new-name
Total 0 (delta 0), reused 0 (delta 0)
To github.com:datreeio/commit-test.git
– [deleted]             old-name
* [new branch]      new-name -> new-name
-> commit-test git:(new-name) $ git push origin -u new-name
Branch new-name set up to track remote branch new-name from origin.
Everything up-to-date

Git tip: want to make sure all branch names will always follow your convention? Set a Git-enforced branch naming policy.