# GIT CHEAT SHEET

A humble attempt to create a easy on the eye, skimable git cheat sheet. Please comment with requests, improvement suggestions or corrections. 

## Starting a Repo init/clone/remote

**Create or Initialize** a repo from **existing** code or files
> git init	

**Clone** a current repo (into a folder with same name as repo)
> git clone (repo_url)	

**Clone** a repo into a **specific folder** name
> git clone (repo_url) (folder_name)	

**Clone** a repo into **current directory** (should be an **empty directory**)
> git clone (repo_url) .	

**Create** a remote repo **named origin**
pointing at your Github repo (after you've already created the repo on Github) (used if you git init since the repo you created locally isn't linked to a remote repo yet)
> git remote add origin https://github.com/username/(repo_name).git	

**Create a remote** repo named **origin** pointing at your **Github repo** (using SSH url instead of HTTP url)
> git remote add origin git@github.com:username/(repo_name).git	

**Show** the names of the **remote repositories** you've set up
> git remote

Show the names and URLs of the remote repositories
> git remote -v	

**Remove** a **remote** repository
> git remote rm (remote_name)	

**Change** the **URL** of the git **remote**
> git remote set-url origin (git_url)	

**Push** your changes **to** the **origin**
> git push	



## Showing Changes status/diff/log/blame
Show the **files changed**
> git status	

Show **changes** to files **compared** to **last commit**
> git diff	

Show **changes** in single **file** compared to **last commit**
> git diff (filename)	

Show **changes** between two different **commits**.
> git diff (commit_id)	

Show **history** of changes
> git log	

Show **who changed each line** of a file and when
Commit ID: This can be that giant long SHA-1 hash. You can call it many different ways. I usually just use the first 4 characters of the hash.
> git blame (filename)	


## Undoing Changes reset/revert

Go **back to the last commit** (will not delete new unstaged files)
> git reset --hard	

Undo/revert last commit AND create a new commit
> git revert HEAD	 

Undo/revert a specific commit AND create a new commit
> git revert (commit_id)	


## Staging Files add/rm
Stage **all** files (new, modified, and deleted)
> git add -A	

Stage **new and modified** files (not deleted)
> git add .	

Stage **modified and deleted** files (not new)
> git add -u	

**Remove** a file and **untrack** it
> git rm (filename)	

**Untrack** a file **only**. It will still exist. Usually you will add this file to .gitignore after rm
Git Workflow Trees: How adding and committing moves files between the different git trees.
Working Tree	The "tree" that holds all our current files.
Index (after adding/staging file)	The "staging" area that holds files that need to be committed.
HEAD	Tree that represents the last commit.
> git rm (filename) --cached	


## Publishing commit/stash/push

**Commit** the local **changes** that were staged
> git commit -m "message"	

**Stage files** (modified and deleted, not new) and commit
> git commit -am "message"	

Take the **uncommitted work** (modified tracked files and staged changes) and **saves it**
> git stash	

Show **list of stashes**
> git stash list	

**Reapply** the latest **stashed** contents
> git stash apply	

**Reapply** a **specific stash**. (stash id = stash@{2})
> git stash apply (stash_id)	

**Drop** a specific **stash**
> git stash drop (stash_id)	

**Push** your changes to the origin
> git push	

**Push** a **branch** to the **origin**
> git push origin (local_branch_name)	

**Tag** a version (ie v1.0). **Useful** for Github **releases**.
> git tag (tag_name)	


## Updating and Getting Code fetch/pull
Get the **latest changes** from origin (_don't merge_)
> git fetch	

Get the **latest changes** from origin **AND merge**
> git pull	

**Checkout** a remote **branch** from origin into a local branch (naming the branch and switching to it)
> git checkout -b (new_branch_name) origin/(branch_name)	


## Branching branch/checkout

**Show all** branches (**local**)
> git branch	

**Show all** branches (local and **remote**)
> git branch -a	

**Create** a branch **from HEAD** (latest)
> git branch (branch_name)	

**Create** a new **branch** and **switch** to it
> git checkout -b (branch_name)	

**Switch** to an already created **branch**
> git checkout (branch_name)	

**Push** a **branch** up to the origin (Github)
> git push origin (branch_name)	

**Get** a **remote** branch from origin into a **local** branch (naming the branch and switching to it)
> git checkout -b (new_branch_name) origin/(branch_name)	

**Delete** a branch **locally** and **REMOTELY**
> git push origin --delete (branch_name)	


## Integrating Branches merge/rebase

**Checkout** a **branch** by name
> git checkout master

**Merge** a specific **branch** into the **current** branch.
> git merge (branch_name)	


Take **all the changes** in one branch and **replay** them on another **branch**. Usually used in a feature branch. Rebase the master to the feature branch so you are testing your feature on the latest main code base. Then merge to the master.
> git rebase (branch_name)	

**Merge/Cherry Pick** one specific **commit** from another **branch** to your **current** branch.
> git cherry-pick (commit_id)	


_


_Resources:_

https://scotch.io/bar-talk/git-cheat-sheet