Git Cheat Sheet: Download PDF for Quick Reference

Installing on Linux

If you want to install the basic Git tools on Linux via a binary installer, you can generally do so through the package management tool that comes with your distribution. If you are on operating systems such as Fedora you can use dnf.

$ sudo dnf install git-all

If you are on a Debian-based distribution, such as Ubuntu use the following command

$ sudo apt install git-all

Installing on macOS

There are several ways to install Git on a Mac. The easiest way is to install it from the Github website

https://mac.github.com

Installing on Windows

There are also a few ways to install Git on Windows. The most official build is available for download on the Git website. 

https://git-scm.com/download/win

$ git config --global user.name "[name]"

Sets the name you want to be attached to your commit transactions.

$ git config --global user.email "[email address]"

Sets the email you want to beattached to your commit transactions.

$ git config --global color.ui auto

Enables helpful colorization of the command line output

$ git config –global alias

Creates a Git command shortcut

$ git config –system core.editor

Sets the preferred text editor

$ git config –global –edit

Open and edit the global configuration file in the text editor

$ git init [project-name]

Creates an empty repository in the project folder with the specified name

$ git clone (repo URL)

Downloads a project from a remote service such as Github and its entire version history 

$ git clone (repo URL) (folder)

Clones a repository to a specific folder

$ git remote -v

Displays a list of remote repositories with URLs

$ git remote rm (remote repo name)

Removes a remote repository

$ git fetch

Fetching from a repository grabs all the new remote-tracking branches and tags without merging those changes into your own branches.

$ git pull

Retrieve the most recent changes from origin and merge

$ git add (file name)

Adds file changes to staging. Snapshots the file in preparation for versioning.

$ git add 

Adds all directory changes to staging

$ git add -A

Adds new and modified files to staging

$ git rm (file_name)

Removes a file and stops tracking it. Deletes the file from the working directory and stages the deletion

$ git rm –cached (file_name)

Removes the file from version control but preserves the file locally

$ git checkout <deleted file name>

Recovers a deleted file and prepares it for commit

$ git status

Displays the status of modified files. Lists all new or modified files to be committed

$ git diff

Displays all unstaged changes in the index and the current directory. Shows file differences that are not yet staged

$ git diff --staged

Shows file differences between staging and the last file version.

$ git reset [file]

Unstages the file, but preserve its contents

$ git commit -m "[descriptive message]"

Records file snapshots permanently in version history

$ git mv [file-original] [file-renamed]

Changes the file name and prepares it for commit

$ git reset [commit]

Undo all commits after [commit], preserving changes locally

$ git reset --hard [commit]

Discards all history and changes back to the specified commit

$ 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 your current branch

$ git branch -d [branch-name]

Deletes the specified branch

$ git fetch remote <branchname>

Fetches a branch from the repository

$ git push –all

Pushes all local branches to a designated remote repository

$ git stash

Temporarily stores all modified tracked files

$ git stash pop

Restores the most recently stashed files

$ git stash list

Lists all stashed changesets

$ git stash drop

Discards the most recently stashed changeset

$ 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 and conflicts between two branches

$ git show [commit]

Outputs metadata and content changes of the specified commit

Branch

Branches represent specific versions of a repository that “branch out” from your main project. Branches allow you to keep track of experimental changes you make to repositories and revert to older versions

Commit

Each time you save/commit the state of your project in Git, it basically takes a picture of what all your files look like at that moment and stores a reference to that snapshot. To be efficient, if the files have not changed, Git does not store the file again but has a link to the previous identical file it has already stored. 

Checkout

The git checkout command switches between branches or restores working tree files. It is used to undo the effects of changes to your repository.

Fetch

The Git fetch command copies and downloads all of a branch’s files to your device. Use it to save the latest changes to your repositories. It is possible to fetch multiple branches simultaneously

Index

Whenever you add, delete or alter a file, it remains in the index until you are ready to commit the changes. It is like a staging area for Git. Use the Git status command to see the contents of your index. 

Repositories

Git repositories hold all of your project’s files including branches, tags, and commits

Pull

Pull requests represent suggestions for changes to the master branch. The Git pull command is used to add changes to the master branch

Push

The git push command is used to update remote branches with the latest changes you have committed

Stash

Stashing takes the state of your working directory — that is, your modified tracked files and staged changes — and saves it on a stack of unfinished changes that you can reapply at any time.

Staging

The staging area is a simple file, generally contained in your Git directory that stores information about what will go into your next commit. It's sometimes referred to as the index.