Skip to content

Git Cheatsheets

Repo hosting: BitBucket GitHub

Common Commands

  • Create a new Git repository in current directory:
git init
  • Or create an empty Git repository in the specified directory:
git init <directory>
  • Or copy an existing Git repository:
git clone <repo URL>
  • Clone the repository located at into the folder called on the local machine:
git clone <repo> <directory>
git clone username@host:/path/to/repository
  • Global Configuration:
$ git config --global user.name "Firstname Lastname"
$ git config --global user.email "your_email@youremail.com"
  • Stage all changes in <file> for the next commit:
git add <file>
  • Or stage all changes in <directory> for the next commit:
git add <directory>  # usually '.' for current directory
  • Commit the staged snapshot to the project history:
git commit  # interactive   
git commit -m "<message>"
  • Or add and commit all in one:
git commit -am "message"
  • Fix up the most recent commit (don't do that if shared history):
git commit --amend
  • List which files are staged, unstaged, and untracked:
git status
git status -s  # short format
  • Show file diff:
git diff           #  git diff by itself doesn’t show all changes made since your last commit – only changes that are still unstaged.
git diff --staged  #  Shows file differences between staging and the last file version
  • Open GUI:
git gui
  • Displays committed snapshots:
git log -n <limit>
git log --graph --decorate --oneline
  • Checking out commits, and checking out branches:
git checkout <commit>       #  Return to commit
git checkout master         #  Return to the master branch (or whatever branch we choose)
  • Check out a previous version of a file:
git checkout <commit> <file>    #  Check out the version of the file from the selected commit
git checkout HEAD hello.py      #  Check out the most recent version

Branches

Branches are just pointers to commits.

  • List all of the branches in your repository. Also tell you what branch you're currently in ('*' branch):
git branch
  • Create a new branch called <branch>.
git branch <branch>

This does not check out the new branch. You need:

git checkout <existing-branch>

Or direcly create-and-check out <new-branch>.

git checkout -b <new-branch>
  • Safe delete the branch:
git branch -d <branch>
  • Merge the specified branch into the current branch:
git merge <branch>
  • Undo any undesired changes

Generate a new commit that undoes all of the changes introduced in <commit>, then apply it to the current branch

git revert <commit>

git revert undoes a single commit — it does not “revert” back to the previous state of a project by removing all subsequent commits.

  • Reset (dangerous method - erases history):
git reset
  • List the remote connections you have to other repositories.
git remote -v
  • Create a new connection / delete a connection to a remote repository.
git remote add <name> <url>  # often "origin"
git remote rm <name>         # delete
  • Fetch the specified remote’s copy of the current branch and immediately merge it into the local copy. This is the same as git fetch <remote> followed by git merge origin/<current-branch>.
git pull <remote>
  • Put my changes on top of what everybody else has done. Ensure a linear history by preventing unnecessary merge commits.
git pull --rebase <remote>
  • Transfer commits from your local repository to a remote repo.
git push <remote> <branch>
  • Pushes the current branch to the remote server and links the local branch to the remote so next time you can do git pull or git push.
git push -u origin <branch>

Typical Workflows

Clone a Repo

$ mkdir repos
$ cd ~/repos
$ git clone https://<url>
$ ls -al  <repo dir>

Add a change in the working directory to the staging area

$ git status
$ git add README

-A, --all finds new files as well as staging modified content and removing files that are no longer in the working tree.

$ git add -A
$ git commit -m "Add repo instructions"
$ git push -u origin master
$ git pull
$ ssh -p 2222 user@domain.com

Short-lived topic branches

  • Start a new feature:
git checkout -b new-feature master
  • Edit some files:
git add <file>
git commit -m "Start a feature"
  • Edit some files
git add <file>
git commit -m "Finish a feature"
  • Merge in the new-feature branch
git checkout master
git merge new-feature
git branch -d new-feature

Push and pull from a centralized repo

  • To push the master branch to the central repo:
git push origin master

If local history has diverged from the central repository, Git will refuse the request.

git pull --rebase origin master

Sync my local repo with the remote repo

git pull origin master
git add filename.xyz
git commit . -m “comment”
git push origin master

Create a central Repo

The --bare flag creates a repository that doesn’t have a working directory, making it impossible to edit files and commit changes in that repository. Central repositories should always be created as bare repositories because pushing branches to a non-bare repository has the potential to overwrite changes.

$ git init --bare foobar.git  
$ git rev-parse --show-toplevel     # print top-level directory
$ git rev-parse --git-dir           # print .git directory name