Git Reference

Edit me

Concepts and Definitions

a project tracked by Git, consisting of commits & branches, usually stored with project files and directories in a working directory
working directory
aka. working tree or workspace, the directory containing a working copy of project files and directories
index (aka. cache or stage)
staging area for building a commit of changes in the working directory
commit history
a database storing past commits
a snapshot or record of changes to files in the working directory at some point in time
a reference to a commit at the end of a chain of commits
a reference to the commit that is currently checked out
merge commit
a special type of commit object that joins two (or more) branches
merge conflict
a condition that arises from a failed automatic merge; requires manual editing to resolve the conflict

Ref Notation

Reference to the commit currently checked out
in the following, this denotes a placeholder for a branch, tag, or the SHA-1 hash of a commit object
the nth parent of ref, where n=1 when omitted (only merge commits have multiple parents)
the nth ancestor of ref, where n=1 when omitted
the nth reflog entry of ref


denotes the parent of the HEAD commit
great grandparent of the latest commit on master
HEAD’s great-great-great grandparent’s 2nd parent
previous value of HEAD
example of a reference to a commit by SHA-1 hash (unique ID)

First-time Setup

You must configure Git the first time before using it. Perform this one-time configuration if you just installed Git or if you already had Git installed but never used it.

The first thing you should do is set your user name and email address. This is important because every Git commit uses this information, and it’s immutably baked into the commits you start creating:

git config --global "Foo Bar"
git config --global ""

Next, you should generate and register your SSH key.

Run this command and answer the prompts to generate your key-pair:

ssh-keygen -t rsa

Then, run this command:

cat ~/.ssh/

Copy and paste the output to your SSH keys on the remote server (e.g. GitLab or GitHub).

Creating a New Repository

mkdir myrepo
cd myrepo
git init
# create or add files
echo hello > foo.txt
git add .
git commit -m "initial commit"

Push an Existing Repo to a Remote

git remote add origin remote-repo
git push --all –u origin

Downloading a Repository

git clone remote-repo

…where remote-repo is a path of the form user@server:/path/to/repo

Viewing Changes

git status
View list of changed files
git diff
View changes to files in the working directory
git diff --cached
View changes between index and HEAD commit

Committing Changes

git add file
git commit
Add changes in file to the index, and then
commit staged changes in the index to the local repo
git commit file
Same as the above two commands, except file must already be tracked

To commit all changes to tracked files and new or removed files:

git add --all
git commit -m "commit message"

Commit all changes (to tracked files only):

git commit -a -m "commit message"


git branch branch
Create a new branch named branch at the HEAD (current commit)
git checkout branch
Checkout (i.e. switch to) branch
git checkout -b branch
Same as the above two commands run together, i.e. create a new branch named branch at the current commit and then check it out
git branch -d branch
Delete the branch named branch

Merging Branches

To merge branch2 into branch1:

git checkout branch1
git merge branch2

Undoing Commits

git reset commit
Rewind the current branch to commit, for example git reset HEAD^ rewinds the last commit. (never do this on published commits!)
git revert commit
This does not do what you would think it does. This creates a new commit to undo the changes of a previous commit.

Viewing History

git log
List commit history of the current branch
git log --oneline
Show one per line
git log --follow file
Show history of file
git show ref
View changes in commit
git blame file
See who changed what (and when) in a given file
git diff AB
Compare two branches


Doing a rebase sequentially regenerates a series of commits onto another branch.

git checkout B

git rebase A
Rebase branch B onto A
git rebase --onto A C [B]
Rebase branch B starting at commit C onto branch A. If B isn’t specified, rebase up to and including HEAD.

Pushing and Pulling

git push
Upload commits to default upstream remote repository (To set default upstream: git push -u remote branch)
git push remote branch
Push new commits on branch to remote, e.g. git push origin master
git pull
Pull the latest commits from the upstream repository (does a fetch and merge)
git pull remote branch
Pull latest commits on branch from remote

Restoring Files

git checkout commit -- file
Restore file from the given commit
git checkout HEAD -- file
Discard uncommitted changes to file
git reset --hard HEAD
Discard all uncommitted changes

Staging Files

git add file
Add changes in file to index
git reset file
Unstage file (remove file from index), e.g. to keep it from being committed when you do git commit

Resolving Merge Conflicts

git status
List the files with conflicts
vim file
Edit files to fix conflicts…
<<<<<<< HEAD
text changed in current branch
text changed in other-branch
>>>>>>> refs/heads/other-branch

…or use a dedicated merge tool:

git mergetool

Then, git add file to mark each file resolved and finally git commit to conclude the merge. Alternatively, run git merge --abort to cancel the merge.