DEV Community

Cover image for Git Cheatsheet for 2022
Mursal Furqan Kumbhar
Mursal Furqan Kumbhar

Posted on • Updated on

Git Cheatsheet for 2022

Hello Awesome Developers
I know it had been a long gap since my last article, but I was prepping an even better thing for you all. Here I present the Git Cheatsheet for 2022. A must have/know guide for all developers/programmers.

Basic Concepts

main: default development branch
origin: default upstream repository
HEAD: current branch
HEAD^: parent of HEAD
HEAD~4: great-great grandparent of HEAD and so on


git config --global "Mursal Furqan"
git config --global ""

  • Start a project: git init <directory>
  • Clone a Repo: git clone <url>

Make a Change

  • Add a file to staging: git add <file>
  • Stage all files: git add .
  • Commit all staged files to git with a message: git commit -m "Message goes here"
  • Commit all changes made to tracked files and commit: git commit -am "Message Goes Here"


  • Add -r flag to show all remove branches. Add -a flag for all branches: git branch
  • Create a new branch: git branch <branch-name>
  • Switch to a new branch and update the working directory: git checkout <branch>
  • Create a new branch and switch to it: git checkout -b <new-branch>
  • Delete a merged branch: git branch -d <branch>
  • Delete a branch, whether merged or now: git branch -D <branch>
  • Add a tag to current commit (often used for new version releases): git tag <tag-name>


Merge branch a into branch b. Add -no-ff option for no-fast-forward-merge

  • Merge

git checkout b
git merge a

  • Merge and squash all commits into one new commit: git merge -- squash a


  • Rebase feature branch onto main (to incorporate new changes made to main). Prevents unnecessary merge commits into feature, keeping history clean:

git checkout feature
git rebase main

  • Interactively clean up a branch's commits before rebasing onto main: git rebase -i main
  • Interactively rebase the last 3 commits on current branch: git rebase -i Head~3

Undoing Things

  • Move (&/or rename) a file & stage move: git mv <existing_path> <new_path>
  • Remove a file from working directory & staging area, then stage the removal: git rm <file>
  • Remove from staging area only: git rm --cached <file>
  • View a Previous Commit (READ ONLY): git checkout <commit_ID>
  • Create a new commit, reverting the changes from a specified commit: git revert <commit_ID>
  • Go back to a previous commit & delete all commits ahead of it (revert is safer). Add --hard flag to also delete workspace changes (BE VERY CAREFUL): git reset <commit_ID>

Review your Repository

  • List new or modified files not yet committed: git status
  • List commit history, with respective IDs: git log --online
  • Show changes to unstaged files, add --cached option: git diff
  • Show changes between two commit: git diff commit1_ID commit2_ID


  • Store modified & staged changes. To include untracked files, add -u flag. For untracked & ignored files, add -a flag: git stash
  • As above, but add a comment: git stash save "comment"
  • Partial stash. Stash just a single file, a collection of files, or individual changes from within files: git stash -p
  • List all stashes: git stash list
  • Re-Apply the stash without deleting it: git stash apply
  • Re-Apply the stash at index 2, then delete it from the stash list. Omit stash@(n) to pop the most recent stash: git stash pop stash@(2)
  • Show the difference summary of stash 1. Pass the -p flag to see the full difference: git stash show stash@(1)
  • Delete stash at index 1. Omit stash@(n) to delete last stash made: git stash drop stash@(1)
  • Delete all stashes: git stash clear


  • Add a remote Repo: git remote add <alias> <url>
  • View all remote connections. Add -v flag to view URLs: git remote
  • Rename a Connection: git remote rename <old> <new>
  • Fetch all branches from remote repo (no merge): git fetch <alias>
  • Fetch a specific branch: git fetch <alias> <branch>
  • Fetch a remote repo's copy of the current branch, then merge: git pull
  • Move (rebase) your local changes onto the top of new changes made to the remote repo (for clean, linear history): git pull --rebase <alias>
  • Upload local content to remote repo: git push <alias>
  • Upload to a branch (can then pull request): git push <alias> <branch>

Top comments (0)