Git Command Cheat Sheet [7 Important Hacks]

# go to the location of your script
# initialize git within your application folder
$ cd /your/folder/dir/your-script 
$ git init 

# add all your initial files
# make a commit with a comment
$ git add . 
$ git commit -m "initial commit"

# set the offsite location where your repo is stored
# then doublecheck that your remote location set corectly
$ git remote add origin https://github.com/(YOUR GITHUB REPO PATH) 
$ git remote -v 

# push the local commit to your master branch 
$ git push --set-upstream origin master

# create and switch to a new branch 
# (DO NOT work out of the "master" branch)
# verify you are on the dev branch
$ git branch -b dev
$ git branch -a

# push that branch to the remote repo
$ git push --set-upstream origin dev

# go to the location where you want to set up your script
$ cd /your/folder/dir/your-script 

# clone / download the script from the remote repo
# (do not forget to add the "." at the end to download inside your folder)
$ git clone https://github.com/(YOUR GITHUB REPO PATH) .

# switch to the "dev" branch (DO NOT work on "master")
# and verify that you're on that branch
$ git checkout dev
$ git branch -a

# pull any updated code from this branch to make sure you have the latest updates
$ git pull

# Fetch all changes
# Checkout master and pull the latest code
$ git fetch -a 
$ git checkout master
$ git pull 

# Create and switch to a new branch
$ git checkout -b new-branch

# Make changes and test locally.
# When you are ready, add files and commit changes.
# Repeat until you're ready to merge.
$ git add .
$ git commit -m "my new changes"
$ git push 

# If another developer makes changes to this branch,
# then fetch all current code, stash your local changes,
# pull the most recent branch code, unstash your changes,
# and continue developing.
$ git fetch -a
$ git stash
$ git pull
$ git stash pop

# If you are ready to merge, then fetch the latest code.
# Pull the master or parent branch into the new-branch
$ git fetch -a
$ git pull orign master

# Fix any conflicts, add files again and commit up
$ git add .
$ git commit -m "conflicts fixed!"
$ git push

# continue to Github and create a pull request
# to compare code between branches and merge.

# Save uncommited changes and reverts files to committed versions.
# Useful for pulling down an updated branch.
# Any new files (unrelated to committed files) will not be stashed.
$ git stash

# Stash all types of files (changed old files and new files).
$ git stash -u

# Check to make sure the files you are expecting are stashed.
$ git status

# Un-stash your changes and apply them back to committed files.
$ git stash pop

# Lost track of what you have stashed? List current stashes.
$ git stash list

# Delete all stashes.
$ git stash clear

# fetch all updates to your local computer, but don't apply them
# go to the 
$ git fetch —all
$ git checkout (your branch)

# reset your local branch to remote branch
# all changes will be discarded
$ git reset —hard origin/(your branch)
$ git pull

# List current tags
$ git list

# Create an annotated tag with a message
# format: 
#    git tag 
#    -a (for annoted) 
#    v1.4.1 (for the version number)
#    -m "my version 1.4.1" (text message for notes)
$ git tag -a v1.4.1 -m "my version 1.4.1"

# Push a single tag to the remote repo
$ git push origin v1.5

# Push all tags to the remote repo
git push origin --tags

# swith to the branch you want to rename 
# and change the name
$ git checkout old_branch_name
$ git branch -m "new_branch_name"

# push the branch to the remote repo
# and set your local branch to be connected to the new remote branch name
$ git push origin :"old_branch_name" "new_branch_name"
$ git push origin -u "new_branch_name"