Git Cheatsheet for 2022
Tags: git, beginners, programming, tutorial
Published: 2022-02-04 13:18:35

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

## Setup
```git config --global user.name "Mursal Furqan"
git config --global user.email "mursalfurqan@gmail.com"```
- 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"`

## Branches
- 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>`

## Merging
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`

## Rebasing
- 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`

## Stashing
- 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`

## Synchronizing
- 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>`