My Git Cheatsheet

📅 2016-Jan-02 ⬩ ✍️ Ashwin Nanjappa ⬩ 🏷️ cheatsheet, git ⬩ 📚 Archive

Git incantations that I need to lookup sometimes:

Revision information

Show all the information associated with a revision:

$ git show 123456

This shows the revision’s hash, author, commit message and a full diff of all the files in the revision.

Show only the names of files changed in a revision:

$ git show --name-only 123456

Show only the name and status of files changed in a revision:

$ git show --name-status 123456

Check if a revision exists in the repo:

$ git show 123456
fatal: ambiguous argument '123456': unknown revision or path not in the working tree.

Above is an example of a revision that is not in the repo.

To refer to a revision by a substring from its commit message:

$ git show ":/foobar"

This chooses the most recent revision which has foobar in its commit message.

All other ways to refer to a revision are listed here in the documentation.

Working copy

When you clone a repo, Git automatically checks out the master branch. To clone and check out a different branch:

$ git clone git@github.com:joe/foobar --branch branch123

To clone only the latest revision
To unstage all the files in the index:

$ git reset

This moves all the files in the index back into the working directory.

To unstage a staged file:

$ git reset HEAD file123

This moves the file out from the index back to the working directory.

To revert a staged or modified file back to its last commit:

$ git checkout -- file123

To revert all modified files:

$ git reset --hard

To revert a specific revision from the past and add that reverted change as a new revision:

$ git revert sha_hash_of_revision_123

To revert a series of specific revisions from the past and add each of those reverted changes as new revisions:

$ git revert sha_hash_of_revision_700
$ git revert sha_hash_of_revision_99
$ git revert sha_hash_of_revision_1

Though you can revert revisions in any order, I like to revert in opposite order of history. That is, revert the latest revision first and so on.

To revert a series of specific revisions from the past and create a single new revision out of them:

$ git revert --no-commit sha_hash_of_revision_700
$ git revert --no-commit sha_hash_of_revision_99
$ git revert --no-commit sha_hash_of_revision_1
$ git commit

The --no-commit stages the reverted changes, but does not commit them. So, we follow them up with a commit.

To undo or delete the last commit and also completely lose all of its changes:

$ git reset --hard HEAD~1

To undo or delete the last commit, and keep its changes as unstaged changes in the working directory:

$ git reset --soft HEAD~1

To remove all untracked files from the local repo directory:

$ git clean -fd

This does not touch files ignored by git (.gitignore).

To remove all untracked files (including git ignored files) from the local repo directory:

$ git clean -fdx

This pretty much restores the repo directory to a pristine state with no extraneous files.

To revert non-staged non-committed changes:

$ git checkout file123

To checkin an empty directory - well that is not possible since Git will not do that. A common method folks have been using is to put an empty .gitkeep file in the empty directory and check that file in.

$ mkdir empty_dir
$ touch empty_dir/.gitkeep
$ git add empty_dir/.gitkeep

Branches

Create a new branch from current revision of current branch:

$ git branch branch123

Create branch from a specific revision:

$ git branch branch123 revision_hash_678

Rename the current branch:

$ git branch -m new_branch_name

Rename some branch:

$ git branch -m old_branch_name new_branch_name

To delete a local branch:

$ git branch -d branch_name

Note that you cannot delete the current branch. Checkout to a different branch and then delete the branch you wanted to. This is because imagine chopping off the branch of a tree you are sitting on. You will fall down! 😁

To list all the branches that contain a given commit 01234:

$ git branch -vva --contains 01234

To diff a file between two branches:

$ git diff branch1 branch2 -- path/to/file
$ git difftool branch1 branch2 -- path/to/file

Here the assumption is that branch2 has the updated changes, so is placed after branch1.

To get the new changes from one branch from_branch to another branch to_branch as a commit:

$ git diff to_branch from_branch | git apply --index -
$ git commit

To find first commit of a branch:

$ git log --oneline master..branch1 | tail -1

Merge

To merge other branch to current branch:

$ git checkout current_branch
$ git merge other_branch

To merge remote branch to current branch:

$ git fetch remote_123
$ git merge remote_123/remote_branch_678

To resolve merge conflicts using GUI tool:

$ git mergetool

Rebase

To rebase current branch on top of another branch:

$ git checkout current_branch_123
$ git rebase another_branch_678

To rebase current branch on top of remote branch:

$ git fetch remote_123
$ git rebase remote_123/remote_branch_678

Remotes

To see all info about remote, its branches and push-pull to it:

$ git remote show remote_name

To rename a remote:

$ git remote rename old_remote_name new_remote_name

To checkout a remote branch:

$ git checkout -b local_branch remote_name/remote_branch

To push the current local branch to a remote branch:

$ git push remote_name remote_branch_name

To push a branch on local to branch on remote:

$ git push remote_name local_branch_name:remote_branch_name

To push the current local branch to a remote branch and make the current local branch track that remote branch:

$ git push -u remote_name remote_branch_name

To push a local branch to a remote branch and make the local branch track that remote branch:

$ git push -u remote_name local_branch_name:remote_branch_name

To delete a remote branch:

$ git push remote_name --delete remote_branch

To checkout a remote branch to a new local branch (of same name) with tracking:

$ git checkout -t remote_name/remote_branch

To make an existing local branch track a remote branch (or change remote tracking branch):

$ git branch local_branch -u remote_name/remote_branch

To rename a remote branch
If some branches have been removed at the remote and you want them removed from the local repository too:

$ git remote prune FOOBAR_REMOTE

Submodules

To list all submodules:

$ git submodule status --recursive

To fetch all submodules:

$ git fetch --all --recurse-submodules

To update all submodules to revision required by main module revision:

$ git submodule update --recursive

To initialize all submodules the first time and update them to revision required by main module revision:

$ git submodule update --init --recursive

To view the commit of a submodule (named foobar) corresponding to a commit (say 999792b) of the main module:

$ git ls-tree 999792b foobar

Misc

To generate patch of commit
To list configuration settings
To view HEAD history of your local repository:

$ git reflog

Find which commit added or deleted a certain string:

$ git log -S foobar

Get the history of a function:

$ git log -L :funcname:/path/to/filename

To change the last commit message:

$ git commit --amend

Show who last modified lines of a file:

$ git blame -C -L 234,234 foobar.cpp

List files that changed between two revisions:

$ git diff --name-only old_rev new_rev

List files that changed and also their status (added/modified/deleted) between two revisions:

$ git diff --name-status old_rev new_rev

Create an archive or zip file of the contents of the entire repo at a given commit:

$ git archive -o out.tar HEAD
$ git archive -o out2.zip SOME_TAG
$ git archive -o out3.zip SOME_COMMIT_HASH

Create a zip file of just the files that were changed by a given commit:

$ git archive -o foobar.zip SOME_REV $(git diff --name-only SOME_REV PREV_REV)