This cheat-sheet is also available on my website.
Git is a distributed version control system for tracking code histories. If you are using MacOS or Ubuntu, Git should have been installed by default, otherwise follow the instructions on git-scm to install it.
For complete beginners I would recommend a Git tutorial on Corey Schafer's Youtube channel. That's how I first learnt Git.
Once git is installed, we need to set up the user name and email address because these user identity variables are required for every git commit. We can use
git config --[option] <variable> "value"
to configure these variables, with [option]
indicating the level of the git config file.
Usually we specify the --global
option to set up the configuration to be used across all repositories we are working with, in which case the configuration will be stored in the ~/.gitconfig
file (this configuration only needs to be done once). We can also specify the --local
option so that it can only affect the single current repository. In this case it will be stored in the ${git-repo-dir}/.git/config
.
Command | Description |
---|---|
git config --global user.name "<name>" |
set up user name to be used across all repos |
git config --global user.email "<email>" |
set up email address to be used across all repos |
git config --list |
list git configuration |
git config --global -e |
open config file |
git config --global core.editor "vim" |
set git editor to vim |
git config --global push.default simple |
set push default behaviour |
push.default
can be set as matching
or simple
. matching
means git will push all local branches to the remote with the matching name. simple
means only the current branch -- this is the default setting from Git 2.0.
When initializing a git repository, we either create a new one or clone one from remote.
Command | Description |
---|---|
git init |
initialize an existing dir as a git repo |
git clone <url> |
clone a repo |
git help [command] or git [command] --help |
get help info |
Command | Description |
---|---|
git status |
check status |
git add [file] |
add a file to the staging area |
git add -A |
add all files in the directory to the staging area |
git reset [file] |
remove a file from the staging area |
git reset |
remove all from the staging area |
git commit -m "[message]" |
commit staged contents |
git commit -am "[message]" |
stage all files that have been modified or added and commit |
git add --patch [file] or git add -p [file] |
stage parts/hunks of a file, prompted with options, e.g., y : stage this hunk n : do not stage this hunk s : split the current hunk into smaller hunks q : quit ? help |
To avoid consistently entering username and password when pushing repositories to GitHub, it is better to establish a secure connection by setting up an SSH key in our GitHub account.
First generate a pair of SSH keys following my SSH tutorial and add the public key to the account following this help document, beginning from step 2.
Finally, use set-url
to change the remote url to SSH.
❗ Do NOT share the private key id_rsa
with anyone.
Command | Description |
---|---|
git push or git push origin [branchname] |
push changes to the remote repo origin is an alias on the local system for the remote repo |
git push -u origin [branchname] |
push changes to the remote repo and associate local branch with the remote repo |
git push origin --delete [branch] or git push origin :[branch] |
delete a remote branch |
git fetch |
fetch updates from remote branches but do not change the local copy |
git fetch --prune |
clean outdated branches that do not exist on the remote |
git pull origin [branchname] |
pull changes from the remote branch: fetch and merge |
git reset origin/master |
set local repo to match the remote branch (after git fetch ) |
git remote -v |
list remote repos |
git remote add origin https://github.com/<user>/[reponame].git |
connect remote server to local |
git remote add origin git@github.com:<user>/[reponame].git |
or use SSH if it is set |
git remote get-url --all origin |
get remote's url |
git remote set-url origin git@github.com:<user>/[reponame].git |
set remote's url with ssh |
git remote rm origin |
remove the remote repo origin |
git stash |
save the current changes on a stack |
git stash push -m <stash_name> |
stash changes with given name |
git stash list |
list stored stashes |
git stash apply <stash@> |
reapply the stashed changes |
Command | Description |
---|---|
git checkout [branchname] |
switch to branch |
git checkout -b [branch] |
create a branch and switch to it |
git branch |
list local branches (the asterisk mark * denotes the current branch) |
git branch -a |
list all branches |
git branch [branchname] |
create a branch |
git branch -d [branch] |
delete a local branch |
git branch -D [branch] |
force delete a branch even it is not fully merged |
git merge [branchname] |
merge the branch into the current working branch |
git merge <commitID> |
merge the change history prior to (including) the specified commit into the current working branch |
git branch --merged |
show branches that have been merged into the current branch |
hub
is a GitHub extension to make GitHub tasks easier. Download hub
release, extract and install it. For instance,
-
Ubuntu
Extract the release to./hub/
andcd hub sudo ./install
-
Windows
Extract the release and run theinstall.bat
file. Usehub
ingit-bash.exe
instead of incmd.exe
, otherwise you would need to addC:\Program Files\Git\bin
to System Path.
Command | Description |
---|---|
hub create |
create a repo with default settings |
hub create -p |
create a private repo |
hub create -d [desc] |
create a repo with description |
For full documentation visit the hub
manual.
In this example, we are going to create a repository and connect it to GitHub. We are going to create a local master
branch first and connect it remotely. Then we will also create a daily working branch, and push it to GitHub for our everyday work. Once we have completed a major section, we merge it into the master
and push the master
to remote.
-
For first-time users, set up git configuration and SSH keys
# git config git config --global user.name "<name>" git config --global user.email "<email addr>" # generate ssh keys # and add the public key on github
❗
id_rsa.pub
is the public key. Do NOT paste theid_rsa
. -
Either clone a repository from remote or create a local repository and push it to github:
# clone a remote repo cd [workspace] git clone <url> git branch -a # to list local and remote branches
# create a local git repo and push to remote # in this case, we also need to create a repo on github # the simple way is to create one on the website # or you can use `hub` command cd [repodir] git init touch [newfile] # and add some contents git add [file] # use `git status` to see if it's staged git commit -m "msg" # or use `git commit -am "msg"` to replace the last two commands # create a repo on github then use the following `git remote` to connect them git remote add origin git@github.com:<user>/[reponame].git # or use `hub` command hub create # then git push origin master git branch -a # will list a local and remote `master` branch
-
Edit files and update the repository in a local working branch
# create a working branch and do everyday tasks in it git checkout -b [branch] touch [file] # and modify git add [file] git commit -m "msg" # then push to remote git push -u origin [branch]
-
Merge the working branch into master
# merge into master git checkout master git pull origin master git merge [branch] # use `git branch --merged` to show merged branches git push origin master
Syntax | Description |
---|---|
<rev>^1 or <rev>^ |
the first parent of the specified commit object |
<rev>^n |
the <n> th parent of that commit |
<rev>^^ or <rev>~2 |
the first grand-parent of the specified commit object following the first parent |
Command | Description |
---|---|
git log |
show git log |
git log --oneline |
show abbreviated git log in one-line format |
git log --abbrev-commit |
show git log with abbreviated commit IDs |
git log --stat |
show git log with change stat |
git log --author=<name> |
show git log messages made by specified author |
git log --grep=<pattern> |
show git log messages with the specified pattern |
git log --graph --oneline --all |
show git log tree in all branches |
git show <commitID> |
show changes in that commit |
git diff |
show unstaged changes |
git diff --staged |
show changes between the staging area and last commit |
git diff <commitID> |
compare with the specified commit |
git diff <oldCommit>..<newCommit> |
compare between two commits |
git diff --stat <oldCommit>..<newCommit> |
show change stat (additions & deletions) between the two |
git commit --amend |
combine staged changes with the previous commit (commit message will be opened) amend will create an entirely new commit, instead of modifying the old commit |
git commit --amend -m "new msg" |
change the most recent commit message to "new msg" |
git commit --amend --no-edit |
commit staged changes to the previous commit without message editing |
git reset HEAD~ |
undo the last commit and leave changes unstaged (HEAD will be copied to .git/ORIG_HEAD ) |
git reset --soft HEAD~ |
undo the last commit and leave changes staged |
git reset --hard <commitID> |
roll back local repo to the specified version and remove previous commits |
git reset --hard origin/[branch] |
reset local branch to match the remote branch |
git push origin [branchname] --force |
force push local repo to remote |
git revert <commitID> |
roll back files and create commit to record rollback history |
git cherry-pick <commitID> |
merge changes from a commit |
git rebase [branchname] |
rewrite the current branch history to follow the commits in the specified branch |
git rebase -i HEAD~2 |
rebase specified last commits in interactive mode |
git rebase --continue |
continue with history rebasing in interactive mode |
git checkout <commitID> [file] |
revert a specified file to the committed reversion and stage changes (not committed) |
git checkout <commitID>~1 [file] |
revert a file to the first parent of the specified commit and stage changes |
Command | Description |
---|---|
git clone --recursive <url> |
clone a repository including its submodules |
git pull --recurse-submodules |
pull changes in the repository including submodules |
git submodule add <url> |
add an existing repository as a submodule under current directory |
git submodule init |
initialize submodule configuration |
git submodule update --remote |
fetch and update all submodules |
Command | Description |
---|---|
git ls-files |
list files under the current path that are being tracked |
- Amending the most recent commit message
git reset # unstaged changes since last commit git commit --amend -m "new msg" # or git commit --amend git push origin [branch] -f # force push commit if that commit was pushed before
- Change the last commit
git commit -m "msg" # commit that needs to be changed # modify files and git add [files] # stage git commit --amend
- Undo the most recent commit
git reset HEAD~ # undo commit and leave changes unstaged # or `git reset --soft HEAD~` to leave changes staged # edit files and git add [file] git commit -c ORIG_HEAD # open editor with previous change commit message git push origin [branch] -f # force push commit if that commit was pushed before
- Add an existing repository as a submodule
# cd to the directory that keeps the submodule and git submodule add <url> git status # will show that the submodule folder is tracked as "new file" git submodule init # fetch and update the submodule git submodule update --remote [sub-repo] cd <sub-repo> git branch -a # should show it's in “detached HEAD” state git checkout master # [or] -b [newbranch] # make changes and commit, and git push origin [branch] cd <main-repo> git status # will show the submodule has "new commits" git add -A git commit -m "msg" git push # push main-repo to remote
There is a .gitignore
template repository available. For .gitignore
syntax please visit the git document.