Git is a free and opensource version control system. Surely, we have more VCS like Bazaar, Mercurial, and SVN. But Git is the most popular and widely used VCS. It is another creation of Linus Torvalds. He created it in 2005 for development of the Linux kernel. In software development, it is used for source code management, especially for tracking changes.
In this blog, we aren’t gonna learn Git. We will just document some very necessary Git commands for day-to-day usage. We are gonna call this document/blog/guide by cheat sheet. A cheat sheet is a quick reference guide. By the way, Git is very easy to learn. You will find tons of tutorials on the internet for that.
Setting up a Git repository Link to heading
A Git repository, mostly known as repo, refers to a virtual storage for saving versions of a project. Within a repo, we can access all the versions of the project. Let’s assume that you need to initialize a Git repo in any directory. In that case, you may run the following command:
$ git init
If you have any existing repo hosted on the cloud, then you may need to clone it locally:
$ git clone <repo url> <destination>
is an optional command line argument. If you don’t pass it, then the repo will be cloned into the current working directory.
You may want to host your local repo on the cloud, for example, on GitHub, GitLab, or BitBucket. They are all famous source hosting platforms. To host on them, they will provide you a repo URL. You may need to set up this into the local repo:
$ git remote add <remote> <repo url>
is just a name and helps to identify the repo URL by name later.
Configuring Git Link to heading
There are three types of configuration:
- Local: Refers to repository specific configuration stored in /.git/config.
- Global: Refers to user-specific configuration stored in .gitconfig in user’s home directory.
- System: Refers to system-wide configuration stored in /etc/gitconfig.
To set the author name and email of the current user for all commits, we can run the following commands:
$ git config --global user.name <author name>
$ git config --global user.email <author email>
To create a shortcut for Git command, we can run the following command:
$ git config --global alias.<git-alias> <git-command>
Staging Changes Link to heading
Before saving any changes to the repository, we need to stage them. Staging changes refer to adding changes to the repo. To stage changes of a file or directory, we can run the following command:
$ git add <file or directory>
To stage changes of all new and modified files and folders (without deleted), we can run the following command:
$ git add .
To stage changes of all modified and deleted files and folders (without new), we can run the following command:
$ git add -u
To stage changes of all new, modified and deleted files and folders, we can run the following command:
$ git add -A
Saving Changes Link to heading
After staging changes, we can save them with a message, called commit. Commit refers to the snapshot of the project. In a repo, we can switch between commits and can go back to any snapshot anytime. To save all staged changes in a repo, we can run the following command:
$ git commit -m "<message>"
Every commit needs a message. A message refers to the changes made with the commit. We need to write a sensible message with every commit.
Using Branches Link to heading
A branch in Git is simply a lightweight movable pointer to one of the commits. In other words, a branch represents an independent line of development. The default branch name in Git is master. To list all branches of a repo, we can run the following command:
$ git branch
To list all remote branches, we can run the following command:
$ git branch -a
To create a new branch, we can run the following command:
$ git branch <branch>
To switch to a branch, we can run the following command:
$ git checkout <branch>
To create a new branch and immediately switch to it, we can run the following command:
$ git checkout -b <branch>
To rename the current branch, we can run the following command:
$ git branch -m <new branch name>
To delete a branch if it doesn’t have unmerged changes, we can run the following command:
$ git branch -d <branch>
To delete a branch forcefully, we can run the following command:
$ git branch -D <branch>
Stashing Changes Link to heading
Stashing refers to saving uncommitted changes for later use and using them when needed. To stash uncommitted changes, we can run the following command:
$ git stash
git stash command doesn’t stash untracked files. To stash uncommitted changes including untracked files, we can run the following command:
$ git stash -u
To stash uncommitted changes including ignored and untracked files, we can run the following command:
$ git stash -a
To use the stashed changes, we can run the following command:
$ git stash apply
To remove the stashed changes and reapply to project, we can run the following command:
$ git stash pop
Assume, we have stashed our current changes. Then, we have stashed again after making some changes. This will create multiple stashes. To see the stash list, we can run the following command:
$ git stash list
To use the stashed changes from the stash list, we can run the following command:
$ git stash pop stash@{<index>}
To create a branch from stash, we can run the following command:
$ git stash branch <branch> stash@{index}
Comparing Changes Link to heading
To compare changes between uncommitted changes and the last commit, we can run the following command:
$ git diff
To compare changes between two different commits, we can run the following command:
$ git diff <commit hash-1> <commit hash-2>
To compare changes between two different branches, we can run the following command:
$ git diff <branch-1> <branch-2>
To compare changes in a file between two different branches, we can run the following command:
$ git diff <branch-1> <branch-2> <file>
Merging Branches Link to heading
Merging branches refers to integrating a branch in another branch. To merge a different branch into the current branch, we can run the following command:
$ git merge <branch>
To merge multiple different branches into the current branch, we can run the following command:
$ git merge <branch-1> <branch-2>
To set the commit message to be used for the merge commit, we can run the following command:
$ git merge <branch> -m "message"
To merge a different branch into the current branch without making a new commit automatically, we can run the following command:
$ git merge --no-commit <branch>
To refuse to merge and exit with a non-zero status unless the current HEAD is already up to date or the merge can be resolved as a fast-forward, we can run the following command:
$ git merge --ff-only <branch>
To create a merge commit even when the merge resolves as a fast-forward, we can run the following command:
$ git merge --no-ff <branch>
To merge and create a single commit on top of the current branch, we can run the following command:
$ git merge --squash <branch>
To continue the merge process after fixing merge conflicts, we can run the following command:
$ git merge --continue
To abort the merge process and try to reconstruct the pre-merge state, we can run the following command:
$ git merge --abort
Syncing a Repository Link to heading
To add a new remote repo, we can run the following command:
$ git remote add <remote> <repo URL>
To rename a remote repo, we can run the following command:
$ git remote rename <old name> <new name>
To remove a remote repo with all remote-tracking branches and configuration settings for the remote, we can run the following command:
$ git remote remove <remote>
Fetching Remote Changes Link to heading
To download commits, files, and refs from a remote repo without integrating into the local repo, we can run the following command:
$ git fetch <remote>
To fetch from all remote repositories, we can run the following command:
$ git fetch --all
To fetch forcefully, we can run the following command:
$ git fetch -f <remote>
Merging Remote Changes Link to heading
To fetch from and merge with another repository or a local branch, we can run the following command:
$ git pull <remote>
To fetch from and merge with another repository or a local branch without creating a new merge commit, we can run the following command:
$ git pull --no-commit <remote>
To fetch from and merge with another repository or a local branch to ensure a linear history by preventing unnecessary merge commits, we can run the following command:
$ git pull --rebase <remote>
Publishing Changes Link to heading
To publish local changes of a branch to the remote repo, we can run the following command:
$ git push <remote> <branch>
To publish local changes of all branches to the remote repo, we can run the following command:
$ git push <remote> --all
To publish local changes forcefully even if it results in a non-fast-forward merge, we can run the following command:
$ git push <remote> --force
To remove a remote branch, we can run the following command:
$ git push origin :<branch>
Inspecting a Repository Link to heading
To see the current state of a repo, we can run the following command:
$ git status
To see the commit history of a repo, we can run the following command:
$ git log
To see the commit history including files and number of lines changes, we can run the following command:
$ git log --stat
To see the precise view of commit history of a repo, we can run the following command:
$ git log --oneline
To see the graphical view of commit history, we can run the following command:
$ git log --graph --decorate --oneline
To see the graphical view of commit history with more details, we can run the following command:
$ git log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit
You can run the following command to create a global shortcut git lg for the above command:
$ git config --global alias.lg "log --color --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
Undoing Changes Link to heading
To remove uncommitted changes of a repo, we can run the following command:
$ git clean
To remove only files ignored by Git, we can run the following command:
$ git clean -X
To remove untracked directories in addition to untracked files, we can run the following command:
$ git clean -d
To change the message of the last commit of a repo, we can run the following command:
$ git commit --amend -m "<message>"
To publish this commit to the remote repo, we need to force push over the old commit:
$ git push --force <branch>
With git log --oneline, we can see the precise view of commit history of a repo with commit hash. Each commit hash refers to a state of the repo. To go to any state of the repo, we can run the following command:
$ git checkout <commit>
When we run this command, the repo is in a ‘detached HEAD’ state. It means the branch ref is still pointing to the latest commit. The HEAD ref has been moved, and now points at . To come back to the current state of the repo, we can come back to the branch in where we were before going to the state of the commit:
$ git checkout <branch>
To change current HEAD and branch ref to the specified commit/state without touching the index file or the working tree at all (but resets the head to and leaves all changed files “Changes to be committed”, as git status would put it), we can run the following command:
$ git reset --soft
To reset the index but not the working tree (i.e., the changed files are preserved but not marked for commit) and reports what has not been updated, we can run the following command:
$ git reset
To reset the index and working tree (any changes to tracked files in the working tree since are discarded), we can run the following command:
$ git reset --hard
To reset the index and update the files in the working tree that are different between and HEAD, but keep those which are different between the index and working tree (i.e. which have changes which have not been added), we can run the following command:
$ git reset --merge
To reset index entries and update files in the working tree that are different between and HEAD, we can run the following command:
$ git reset --keep
When we remember what we just committed is incomplete, or we misspelled our commit message or both and we want to leave working tree as it was before reset, we can run the following command:
$ git reset HEAD~
To change the state of the repo to any previous commit with a commit message, we can run the following command:
$ git revert <commit>
To revert the latest commit, we can run the following command:
$ git revert HEAD
To revert the changes specified by the fourth last commit in HEAD and create a new commit with the reverted changes, we can run the following command:
$ git revert HEAD~3
To continue revert operation after resolving conflicts in a failed cherry-pick or revert, we can run the following command:
$ git revert --continue
To clear the sequencer state after a failed cherry-pick or revert, we can run the following command:
$ git revert --quit
To cancel the operation and return to the pre-sequence state, we can run the following command:
$ git revert --abort
Please be noted that git revert is a safe way to undo changes but git reset is the dangerous method. Also, never reset public history.
References: Atlassian, Git SCM, GitHub Help, Wikipedia