# Git Cheatsheet
### Index
* [Set Up](#setup)
* [Configuration Files](#configuration-files)
* [Create](#create)
* [Local Changes](#local-changes)
* [Search](#search)
* [Commit History](#commit-history)
* [Move or Rename](#move-or-rename)
* [Branches and Tags](#branches-and-tags)
* [Update and Publish](#update-and-publish)
* [Merge and Rebase](#merge-and-rebase)
* [Undo](#undo)
## Setup
##### 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 user.name “[firstname lastname]”
```
##### Set an email address that will be associated with each history marker:
```
$ git config --global user.email “[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]:
```
/.git/config
```
##### User-specific configuration file [--global]:
```
~/.gitconfig
```
##### System-wide configuration file [--system]:
```
/etc/gitconfig
```
## Create
##### Clone an existing repository:
There are two ways:
Via SSH
```
$ git clone ssh://user@domain.com/repo.git
```
Via HTTP
```
$ git clone http://domain.com/user/repo.git
```
##### 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 <file> 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!
```shell
$ git commit --amend --no-edit
```
##### Change committer date of last commit:
```
GIT_COMMITTER_DATE="date" git commit --amend
```
##### Change Author date of last commit:
```shell
$ 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:
```shell
$ git stash apply
```
#### Restore particular stash back to current branch:
- *{stash_number}* can be obtained from `git stash list`
```shell
$ git stash apply stash@{stash_number}
```
##### Remove the last set of stashed changes:
```
$ git stash drop
```
## Search
##### A text search on all files in the directory:
```
$ git grep "Hello"
```
##### In any version of a text search:
```
$ 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 <file>:
```
$ git blame
```
##### Show Reference log:
```
$ git reflog show
```
##### Delete Reference log:
```
$ git reflog delete
```
## Move or Rename
##### Rename a file:
Rename Index.txt to Index.html
```
$ git mv Index.txt Index.html
```
## Branches and 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
```shell
$ 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 and Publish
##### List all current configured remotes:
```
$ git remote -v
```
##### Show information about a remote:
```
$ git remote show
```
##### Add new remote repository, named <remote>:
```
$ git remote add
```
##### Rename a remote repository, from <remote> to <new_remote>:
```
$ 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 <remote>, 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)
```
OR
```
$ git push --delete (since Git v1.7.0)
```
##### Publish your tags:
```
$ git push --tags
```
#### Configure the merge tool globally to meld (editor)
```bash
$ git config --global merge.tool meld
```
##### Use your configured merge tool to solve conflicts:
```
$ git mergetool
```
## Merge and Rebase
##### Merge branch into your current HEAD:
```
$ git merge
```
#### List merged branches
```
$ git branch --merged
```
##### Rebase your current HEAD onto <branch>:
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,
```
pick
pick
pick
```
to this,
```
pick
squash
squash
```
## Undo
##### 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"
```
## Thank you for reading
### If you like what you read and want to see more, please support me with coffee or a book ;)
