git-cheatsheet

git-cheatsheet.md

Cherry Pick

Cherry pick based on a commit by ignoring spaces

HINT: To avoid conflicts, cherry pick with the same order of the original commits (i.e. use Unix tac command to reverse sort the git log)

git cherry-pick -X ignore-all-space <commit_hash>

e.g.

git cherry-pick -X ignore-all-space 123f2fs

---

Patch

Create a patch file based on a commit

git format-patch -1

e.g.

git format-path -1 ccc4752

Create a patch from a feature branch

git format-patch master --stdout > <patch_file_name>

e.g.

# Get Latest Changes
git pull 
# Create and switch to new bug fix branch
git checkout -b bug-fix-branch 
# Perform bug fixes and commit them
# Spit out the patch file
git format-patch master --stdout > bug-fix-1.patch

Apply a patch from a feature branch

git apply --stat <patch_file_name>

git apply --check <patch_file_name>

git am < <patch_file_name>

e.g.

# Review the changes
git apply --stat bug-fix-1.patch
# Simulate if git can apply the change
git apply --check bug-fix-1.patch
# Apply the patch
git am < bug-fix-1.patch
# Patch is applied and committed. Ready to push!

---

Clone

Cloning a remote repository (SSH)

git clone <user@server:path/to/repo.git>

e.g.

git clone [email protected]:TomyJaya/git-real.git

Cloning a remote repository (https)

git clone

e.g.

git clone https://github.com/TomyJaya/git-real.git

---

Status

Checking the Status of Your Files

git status 

---

Staging & Committing

Add a file to staging/ index/ changeset

git add <file_name>

e.g.

git add README.md

Add all files to staging/ index/ changeset

git add .
git add -A

See: http://stackoverflow.com/questions/572549/difference-between-git-add-a-and-git-add

To get the list of file changes in a commit

git diff-tree --no-commit-id --name-status -r <commit_id>

e.g.

git show --pretty="format:" --name-status 53571fc
git --no-pager show --pretty="format:" --name-status 53571fc

To see what you've changed but not yet staged

git diff

If you want to see what youíve staged that will go into your next commit:

git diff --cached
git diff --staged 

Hint: cached and staged are synonymous.

Get the difference of the same file between two different commits on the same branch

git diff <start_commit>..<end_commit> -- <path/to/file>

e.g.

git diff abcsdef..HEAD --ivysettings.xml # between now and abcdef commit
git diff HEAD~2..HEAD --ivysettings.xml # between now and two commmits back

---

Commit your changes

git commit -m ""

e.g.

git commit -m "Initial Commit"

Commit all modified files, by-pass add to index or staging

git commit -am ''

e.g.

git commit -am 'added new benchmarks'

Remove files

git rm

e.g.

git rm PROJECTS.md

Keep the file in your working tree but remove it from your staging area

git rm --cached

e.g.

git rm --cached README

Renaming and Moving Files

git mv <file_from> <file_to>

e.g.

git mv README.md README

---

Logs

Retrieve logs (view commit history)

git log 
git --no-pager log -n 20 --pretty=oneline --abbrev-commit
git log --abbrev-commit --pretty=oneline ###  Get abbreviated commit
git log --pretty=oneline
git log --pretty=format:"%h - %an, %ar : %s"
git log --pretty=format:"%h %s" --graph
git log --graph --oneline
git log --since=2.weeks
# Another really helpful filter is the -S option which takes a string and only shows the commits that introduced a change to the code that added or removed that string.
git log -Sfunction_name 

---

Undo (Reset, Checkout, Revert)

Undoing Things (Changing the last Commit)

git commit -m 'initial commit'
git add forgotten_file.txt
git commit --amend 
# You end up with a single commit & the second commit replaces the results of the first.

WARNING: Don't amend your last commit if you've already pushed it!

Unstage staged files

git reset HEAD <file_name>

e.g.

git reset HEAD CONTRIBUTING.md

⭐ Reverting the whole repo

git reset --hard HEAD~1 

Note: Undo commit/ local commit and nuke last commit and never see it again.

Undo commit/ local commit but keep your changes

git reset HEAD~1

Undo commit/ local but leave your files and your index:

git reset --soft HEAD~1

Revert changes (Unmodifying all modified files)

Hint: Be careful of using this command as you can't get the modification back

git reset --hard

Remove all untracked files and directories

Hint: Be careful of using this command as you can't get the untracked files back

git clean -fd 

⭐ Revert changes (Unmodifying a Modified File) - Discarding Changes

git checkout --

git checkout HEAD

e.g.

git checkout -- CONTRIBUTING.md
git checkout HEAD CONTRIBUTING.md

Note: http://stackoverflow.com/questions/13321458/meaning-of-git-checkout-double-dashes

WARNING: It's important to understand that git checkout -- [file] is a dangerous command. Any changes you made to that file are gone & you just copied another file over it. Don't ever use this command unless you absolutely know that you don't want the file.

DANGEROUS COMMAND:

# The below will discard all unstaged changes!!!
git checkout -- . 

Revert mistakenly checked in file

Note: if you accidentally made a wrong change to a file and committed it, you can get back the last but one checked in file:

git checkout HEAD~1 <file>

---

Remotes

Show all remotes

git remote
git remote -v ###  shows URL

Note: remote repositories are versions of your project that are hosted on the Internet or network somewhere.

Adding remote repository

git remote add

e.g.

git remote add pb https://github.com/paulboone/ticgit

IMPORTANT: http://git-scm.com/book/en/v2/Git-Basics-Working-with-Remotes

• If you clone a repository, the command automatically adds that remote repository under the name ìoriginî. So, git fetch origin fetches any new work that has been pushed to that server since you cloned (or last fetched from) it. It's important to note that the git fetch command pulls the data to your local repository & it doesn't automatically merge it with any of your work or modify what youíre currently working on. You have to merge it manually into your work when youíre ready.
• If you have a branch set up to track a remote branch, you can use the git pull command to automatically fetch and then merge a remote branch into your current branch. This may be an easier or more comfortable workflow for you; and by default, the git clone command automatically sets up your local master branch to track the remote master branch (or whatever the default branch is called) on the server you cloned from. Running git pull generally fetches data from the server you originally cloned from and automatically tries to merge it into the code you're currently working on.

Fetching and Pulling from Your Remotes

git fetch

e.g.

git fetch origin

Pushing to Your Remotes

git push origin master

Inspecting a remote

git remote show origin

Removing and Renaming Remotes

git remote rename pb paul
git remote rm paul

---

Tagging

Listing Your Tags

git tag
git tag -l 'v1.8.5*' ###  search with a particular pattern

Tags (Lightweight and annotated)

Annotated Tags

git tag -a <version_name> -m '<tag_message>'

e.g.

git tag -a v1.0 -m 'my version 1.0'

Show Tag information

git show v1.0

Lightweight tag

git tag v1.4-lw

Tag a previous commit

git tag -a <version_name> <abbreviated_index_checksum>

e.g.

git tag -a v1.2 9fceb02

Sharing Tags

git push origin

e.g.

git push origin v1.5
git push origin --tags ###  transfer all of your tags to the remote server that are not already there

Checking out Tags

Note: You can't really do that, instead, put a version of the repository in your working directory that looks like a specific tag.

###  Create a new branch version2 which has contents as of tag v2.0.0
git checkout -b version2 v2.0.0 

---

Config

Set up Aliases:

git config --global alias.co checkout
git config --global alias.br branch
git config --global alias.ci commit
git config --global alias.st status
###  Can do git unstage file instead of git reset HEAD file
git config --global alias.unstage 'reset HEAD --' 
###  see the last commit easily
git config --global alias.last 'log -1 HEAD' 

---

Branching

List all branches

git branch
git branch -v  ###  with last commit on each branch
git branch --merged ###  only merged branch
git branch --nomerged ###  only unmerged branch

Create a new Branch

git branch <new_branch_name>

Switch to branch

git checkout <branch_name>

e.g.

git checkout branch123 or git checkout master

Shorthand to checkout and create a branch

git checkout -b <branch_name>

Delete branch

git branch -d <branch_name>

Force Delete branch

Note: will delete even if there's unmerged changes

git branch -D <branch_name>

Git fetch and merge a branch

e.g. serverfix

git fetch origin
git merge origin/serverfix

Note: If you want your own serverfix branch that you can work on, you can base it off your remote branch

git checkout -b serverfix origin/serverfix

Tracking Branches

Note: Checking out a local branch from a remote branch automatically creates what is called a "tracking branch" (or sometimes an "upstream branch"). Tracking branches are local branches that have a direct relationship to a remote branch. If youíre on a tracking branch and type git pull, Git automatically knows which server to fetch from and branch to merge into.

git checkout --track origin/serverfix

Add a tracking to an existing local branch

git branch -u origin/serverfix

List tracking branches

git branch -vv

Deleting Remote Branches

git push origin --delete serverfix

---

Rebase

Rebasing

Note: However, there is another way: you can take the patch of the change that was introduced in C4 and reapply it on top of C3. In Git, this is called rebasing. With the rebase command, you can take all the changes that were committed on one branch and replay them on another one.

git checkout experiment
git rebase master
git checkout master
git merge experiment

# Check out the client branch, figure out the patches from the common ancestor of the client and server branches, and then replay them onto master
git rebase --onto master server client 
#  fast-forward your master branch
git checkout master; git merge client

###  You can rebase the server branch onto the master branch without having to check it out first by running git rebase [basebranch] [topicbranch] which checks out the topic branch (in this case, server) for you and replays it onto the base branch (master):
git rebase master server 
###  fast-forward the base branch (master):
git checkout master; git merge server 

IMPORTANT: Do not rebase commits that exist outside your repository.

---

Stashing

Saving changes before switching branch without commit (Stashing)

git stash
git stash save 
git stash -u 
###  Git will also stash any untracked files you have created
git stash --include-untracked 

See list of stash

git stash list

Apply latest stash

git stash apply

apply a specific stash

git stash apply stash@{2}

delete stash

git stash drop stash@{0}

pop stash

git stash pop

Cleaning working directory

git clean
git clean -d -n ###  -n option, which means ìdo a dry run and tell me what you would have removedî.

Create a branch from a stash

git stash branch testchanges

remove everything but save it in a stash.

git stash --all

Miscelleneous

Check for whitespace error

git diff --check

Get history of HEAD

git reflog

Get what was done in a branch yesterday

git show master@{yesterday}

Get all commits reachable by experiment that aren't reachable by master

git log master..experiment

See what you're about to push to a remote:

git log origin/master..HEAD

See all commits that are reachable from refA or refB but not from refC

git log refA refB ^refC
git log refA refB --not refC

Triple Dot: all the commits that are reachable by either of two references but not by both of them.

git log --left-right master...experiment

Git Grep (Search for occurences of string of chars)

git grep -n <phrase> ### will show line number
git grep --count <phrase> ###  will show count
git grep -p <phrase> ###  will find method
git grep --break --heading -n <phrase>  ###  more readable format