Git basic


Git and Git Flow

Git Cheat Sheet


  • Set Up
  • Configuration Files
  • Create
  • Local Changes
  • Search
  • Commit History
  • Branches & Tags
  • Update & Publish
  • Merge & Rebase
  • Undo
  • Git Flow


Show current configuration:

$ git config --list

Show repository configuration:

$ git config --local --list

Show global configuration:

$ git config --global --list

Show system configuration:

$ git config --system --list

Set a name that is identifiable for credit when review version history:

$ git config --global “[firstname lastname]”

Set an email address that will be associated with each history marker:

$ git config --global “[valid-email]”

Set automatic command line coloring for Git for easy reviewing:

$ git config --global color.ui auto

Set global editor for commit

$ git config --global core.editor vi

Configuration Files

Repository specific configuration file [–local]:


User-specific configuration file [–global]:


System-wide configuration file [–system]:



Clone an existing repository:

There are two ways:


$ git clone ssh://


$ git clone

Create a new local repository in the current directory:

$ git init

Create a new local repository in a specific directory:

$ git init 

Local Changes

Changes in working directory:

$ git status

Changes to tracked files:

$ git diff

See changes/difference of a specific file:

$ git diff 

Add all current changes to the next commit:

$ git add .

Add some changes in to the next commit:

$ git add -p 

Add only the mentioned files to the next commit:

$ git add  

Commit all local changes in tracked files:

$ git commit -a

Commit previously staged changes:

$ git commit

Commit with message:

$ git commit -m 'message here'

Commit skipping the staging area and adding message:

$ git commit -am 'message here'

Commit to some previous date:

$ git commit --date="`date --date='n day ago'`" -am ""

Change last commit:

Don’t amend published commits!

$ git commit -a --amend

Amend with last commit but use the previous commit log message

Don’t amend published commits!

$ git commit --amend --no-edit

Change committer date of last commit:

GIT_COMMITTER_DATE="date" git commit --amend

Change Author date of last commit:

$ git commit --amend --date="date"

Move uncommitted changes from current branch to some other branch:

$ git stash
$ git checkout branch2
$ git stash pop

Restore stashed changes back to current branch:

$ git stash apply

Restore particular stash back to current branch:

  • {stash_number} can be obtained from git stash list
$ git stash apply stash@{stash_number}

Remove the last set of stashed changes:

$ git stash drop

A text search on all files in the directory:

$ git grep "Hello"
$ git grep "Hello" v2.5

Show commits that introduced a specific keyword

$ git log -S 'keyword'

Show commits that introduced a specific keyword (using a regular expression)

$ git log -S 'keyword' --pickaxe-regex

Commit History

Show all commits, starting with newest (it’ll show the hash, author information, date of commit and title of the commit):

$ git log

Show all the commits(it’ll show just the commit hash and the commit message):

$ git log --oneline

Show all commits of a specific user:

$ git log --author="username"

Show changes over time for a specific file:

$ git log -p 

Display commits that are present only in remote/branch in right side

$ git log --oneline .. --left-right

Who changed, what and when in :

$ git blame 

Show Reference log:

$ git reflog show

Delete Reference log:

$ git reflog delete

Move / Rename

Rename a file:

Rename Index.txt to Index.html

$ git mv Index.txt Index.html

Branches & Tags

List all local branches:

$ git branch

List local/remote branches

$ git branch -a

List all remote branches:

$ git branch -r

Switch HEAD branch:

$ git checkout 

Checkout single file from different branch

$ git checkout  -- 

Create and switch new branch:

$ git checkout -b 

Switch to the previous branch, without saying the name explicitly:

$ git checkout -

Create a new branch from an exiting branch and switch to new branch:

$ git checkout -b  

Checkout and create a new branch from existing commit

$ git checkout  -b 

Create a new branch based on your current HEAD:

$ git branch 

Create a new tracking branch based on a remote branch:

$ git branch --track  

Delete a local branch:

$ git branch -d 

Rename current branch to new branch name

$ git branch -m 

Force delete a local branch:

You will lose unmerged changes!

$ git branch -D 

Mark HEAD with a tag:

$ git tag 

Mark HEAD with a tag and open the editor to include a message:

$ git tag -a 

Mark HEAD with a tag that includes a message:

$ git tag  -am 'message here'

List all tags:

$ git tag

List all tags with their messages (tag message or commit message if tag has no message):

$ git tag -n

Update & Publish

List all current configured remotes:

$ git remote -v

Show information about a remote:

$ git remote show 

Add new remote repository, named :

$ git remote add  

Rename a remote repository, from to :

$ git remote rename  

Remove a remote:

$ git remote rm 

Note: git remote rm does not delete the remote repository from the server. It simply removes the remote and its references from your local repository.

Download all changes from , but don’t integrate into HEAD:

$ git fetch 

Download changes and directly merge/integrate into HEAD:

$ git remote pull  

Get all changes from HEAD to local repository:

$ git pull origin master

Get all changes from HEAD to local repository without a merge:

$ git pull --rebase  

Publish local changes on a remote:

$ git push remote  

Delete a branch on the remote:

$ git push  : (since Git v1.5.0)


$ git push  --delete  (since Git v1.7.0)

Publish your tags:

$ git push --tags

Configure the merge tool globally to meld (editor)

$ git config --global merge.tool meld

Use your configured merge tool to solve conflicts:

$ git mergetool

Merge & Rebase

Merge branch into your current HEAD:

$ git merge 

List merged branches

$ git branch --merged

Rebase your current HEAD onto :

Don’t rebase published commit!

$ git rebase 

Abort a rebase:

$ git rebase --abort

Continue a rebase after resolving conflicts:

$ git rebase --continue

Use your editor to manually solve conflicts and (after resolving) mark file as resolved:

$ git add 
$ git rm 

Squashing commits:

$ git rebase -i 

Now replace this,


to this,



Discard all local changes in your working directory:

$ git reset --hard HEAD

Get all the files out of the staging area(i.e. undo the last git add):

$ git reset HEAD

Discard local changes in a specific file:

$ git checkout HEAD 

Revert a commit (by producing a new commit with contrary changes):

$ git revert 

Reset your HEAD pointer to a previous commit and discard all changes since then:

$ git reset --hard 

Reset your HEAD pointer to a remote branch current state.

$ git reset --hard  e.g., upstream/master, origin/my-feature

Reset your HEAD pointer to a previous commit and preserve all changes as unstaged changes:

$ git reset 

Reset your HEAD pointer to a previous commit and preserve uncommitted local changes:

$ git reset --keep 

Remove files that were accidentally committed before they were added to .gitignore

$ git rm -r --cached .
$ git add .
$ git commit -m "remove xyz file"


Improved Git-flow


  • Setup
  • Getting Started
  • Features
  • Make a Release
  • Hotfixes
  • Commands


You need a working git installation as prerequisite. Git flow works on OSX, Linux and Windows.

OSX Homebrew:

$ brew install git-flow-avh

OSX Macports:

$ port install git-flow

Linux (Debian-based):

$ sudo apt-get install git-flow

Windows (Cygwin):

You need wget and util-linux to install git-flow.

$ wget -q -O - --no-check-certificate install  | bash

Getting Started

Git flow needs to be initialized in order to customize your project setup. Start using git-flow by initializing it inside an existing git repository:


git flow init


To use default

git flow init -d


Develop new features for upcoming releases. Typically exist in developers repos only.

Start a new feature:

This action creates a new feature branch based on ‘develop’ and switches to it.

git flow feature start MYFEATURE

Finish up a feature:

Finish the development of a feature. This action performs the following:

1) Merged MYFEATURE into ‘develop’.

2) Removes the feature branch.

3) Switches back to ‘develop’ branch

git flow feature finish MYFEATURE

Publish a feature:

Are you developing a feature in collaboration? Publish a feature to the remote server so it can be used by other users.

git flow feature publish MYFEATURE

Getting a published feature:

Get a feature published by another user.

git flow feature pull origin MYFEATURE

Tracking a origin feature:

You can track a feature on origin by using

git flow feature track MYFEATURE

Make a Release

Support preparation of a new production release. Allow for minor bug fixes and preparing meta-data for a release

Start a release:

To start a release, use the git flow release command. It creates a release branch created from the ‘develop’ branch. You can optionally supply a [BASE] commit sha-1 hash to start the release from. The commit must be on the ‘develop’ branch.

git flow release start RELEASE [BASE]

It’s wise to publish the release branch after creating it to allow release commits by other developers. Do it similar to feature publishing with the command:

git flow release publish RELEASE

(You can track a remote release with the:

git flow release track RELEASE


Finish up a release:

Finishing a release is one of the big steps in git branching. It performs several actions:

1) Merges the release branch back into ‘master’

2) Tags the release with its name

3) Back-merges the release into ‘develop’

4) Removes the release branch

git flow release finish RELEASE

Don’t forget to push your tags with

git push --tags


Hotfixes arise from the necessity to act immediately upon an undesired state of a live production version. May be branched off from the corresponding tag on the master branch that marks the production version.

Git flow hotfix start:

Like the other git flow commands, a hotfix is started with

$ git flow hotfix start VERSION [BASENAME]

The version argument hereby marks the new hotfix release name. Optionally you can specify a basename to start from.

Finish a hotfix:

By finishing a hotfix it gets merged back into develop and master. Additionally the master merge is tagged with the hotfix version

git flow hotfix finish VERSION
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post

20 principles I learned from 10 years of developing software

Next Post

What Does a PostgreSQL Commitfest Manager Do and Should You Become One?

Related Posts