1. Create Folder and Initialize

   First we need to create a folder, we'll call this folder "gitTutorial". Then we need to initialize the folder to become a git repository with the command "git init".

2. Adding, Commiting, and Pushing File

   After adding files to the repo, we can start commiting these filesize and pushing them to the repository.

                               
   git add tempFile.html
   git commit -m "enter message here"
   git push -u origin master
                               
                           

   Then after executing git push -u origin master git will ask for the username and password. Enter your username and password to push to the repository. If the user.name and user.email isn't set up, git will ask you to set them up. It will also let you know how to do so.

3. Fetching a Branch

   After pushing a repo you migh want to fetch it from another machine. Fetching is a safer alternative to "pulling" a branch because when you fetch a branch, you don't merge the two branches right away. If you pull a branch then it will automatically merge everything for you and you might not want that. To fetch a branch and merge it with the master do the following:

                               
   git fetch origin
   git merge origin/master
                               
                           

CHEAT SHEET

---

CONFIGURE TOOLING

Configure user information for all local repositories

                    
$ git config --global user.name "[name]"
Sets the name you want attached to your commit transactions

$ git config --global user.email "[email address]"
Sets the email you want attached to your commit transactions

$ git config --global color.ui 
autoEnables helpful colorization of command line output
                    
                

CREATE REPOSITORIES

Start a new repository or obtain one from an existing URL

                    
$ git init [project-name]
Creates a new local repository with the specified name

$ git clone [url]
Downloads a project and its entire version history
                    
                

MAKE CHANGES

Review edits and craft a commit transaction

                    
$ git status
Lists all new or modified files to be committed

$ git add [file]
Snapshots the file in preparation for versioning

$ git reset [file]
Unstages the file, but preserve its contents

$ git diff
Shows file differences not yet staged

$ git diff --staged
Shows file differences between staging and the last file version

$ git commit -m "[descriptive message]"
Records file snapshots permanently in version history
                    
                

GROUP CHANGES

Name a series of commits and combine completed efforts

                    
$ git branch
Lists all local branches in the current repository

$ git branch [branch-name]
Creates a new branch

$ git checkout [branch-name]
Switches to the specified branch and updates the working directory

$ git merge [branch]
Combines the specified branch’s history into the current branch

$ git branch -d [branch-name]
Deletes the specified branch
                    
                

REFACTOR FILENAMES

Relocate and remove versioned files

                    
$ git rm [file]
Deletes the file from the working directory and stages the deletion

$ git rm --cached [file]
Removes the file from version control but preserves the file locally

$ git mv [file-original] [file-renamed]
Changes the file name and prepares it for commit
                    
                

SUPPRESS TRACKING

Exclude temporary files and paths

                    
*.log
build/
temp-*

A text file named .gitignore  suppresses accidental versioning of 
files and paths matching the specified patterns

$ git ls-files --other --ignored --exclude-standard
Lists all ignored files in this project
                    
                

SAVE FRAGMENTS

Shelve and restore incomplete changes

                    
$ git stash
Temporarily stores all modified tracked files

$ git stash list
Lists all stashed changesets

$ git stash pop
Restores the most recently stashed files

$ git stash drop
Discards the most recently stashed changeset
                    
                

REVIEW HISTORY

Browse and inspect the evolution of project files

                    
$ git log
Lists version history for the current branch

$ git log --follow [file]
Lists version history for a file, including renames

$ git diff [first-branch]...[second-branch]
Shows content differences between two branches

$ git show [commit]
Outputs metadata and content changes of the specified commit
                    
                

REDO COMMITS

Erase mistakes and craft replacement history

                    
$ git reset [commit]
Undoes all commits after [commit], preserving changes locally

$ git reset --hard [commit]
Discards all history and changes back to the specified commit
                    
                

SYNCHRONIZE CHANGES

Register a repository bookmark and exchange version history

                    
$ git fetch [bookmark]
Downloads all history from the repository bookmark

$ git merge [bookmark]/[branch]
Combines bookmark’s branch into current local branch

$ git push [alias] [branch]
Uploads all local branch commits to GitHub

$ git pull
Downloads bookmark history and incorporates changes