Git Cheat Sheet #

Git is the free and open source distributed version control system that’s responsible for everything GitHub related that happens locally on your computer. This cheat sheet features the most important and commonly used Git commands for easy reference.

Installation & GUI #

With platform specific installers for Git, GitHub also provides the ease of staying up-to-date with the latest releases of the command line tool while providing a graphical user interface for day-to-day interaction, review, and repository synchronization.

=== “Windows”

There are also a few ways to install Git on Windows. The most official build is available for download on the Git website. Just go to [https://git-scm.com/download/win](https://git-scm.com/download/win) and the download will start automatically.

=== “MacOS” Most versions of MacOS will already have Git installed, and you can activate it through the terminal with git version

``` 
htps://mac.github.com
```

=== “Debian”

``` bash
sudo apt update && apt install git
```

=== “Rhel”

``` bash
sudo dnf install git
```

Git configuration #

$ git config --global user.name “Your Name”

Set the name that will be attached to your commits and tags.

$ git config --global user.email “[email protected]”

Set the e-mail address that will be attached to your commits and tags.

$ git config --global color.ui auto

Enable some colorization of Git output

Starting a project #

!!! tip

A new repository can either be created locally, or an existing repository can be cloned. When a repository was initialized locally, you have to push it to GitHub afterwards.

$ git init [project name]

Create a new local repository. If [project name] is provided, Git will create a new directory name [project name] and will initialize a repository inside it. If [project name] is not provided, then a new repository is initialized in the current directory.

$ git clone [project url]

Downloads a project with the entire history from the remote repository.

Day-To-Day Work #

$ git status

Displays the status of your working directory. Options include new, staged, and modified files. It will retrieve branch name, current commit identifier, and changes pending commit.

$ git add [file]

Add a file to the staging area. Use in place of the full file path to add all changed files from the current directory down into the directory tree.

$ git diff [file]

Show changes between working directory and staging area.

$ git diff --staged [file]

Shows any changes between the staging area and the repository.

$ git checkout -- [file]

Discard changes in working directory. This operation is unrecoverable.

$ git reset [file]

Revert your repository to a previous known working state. !!! warning

Changing history can have nasty side effects. If you need to change commits that exist on GitHub (the remote), proceed with caution. If you need help, reach out at [github.community](https://github.community/) or contact support.

$ git commit -m "<message>"

Create a new commit from changes added to the staging area. The commit must have a message, use <message> as the commit message.

$ git rm [file]

Remove file from working directory and staging area.

!!! tip

Temporarily store modified, tracked files in order to change branches

$ git stash

Put current changes in your working directory into stash for later use.

$ git stash pop

Apply stored stash content into working directory, and clear stash.

$ git stash drop

Delete a specific stash from all your previous stashes.

Git branching model #

{ loading=lazy }

!!! tip

Branches are an important part of working with Git. Any commits you make will be made on the branch you’re currently “checked out” to. Use `git status` to see which branch that is.

$ git branch [-a]

List all local branches in repository. With -a: show all branches (with remote).

$ git branch [branch_name]

Create new branch, referencing the current HEAD.

$ git checkout [-b][branch_name]

Switch working directory to the specified branch. With -b: Git will create the specified branch if it does not exist.

$ git merge [from name]

Join specified [from name] branch into your current branch (the one you are on currently).

$ git branch -d [name]

Remove selected branch, if it is already merged into any other. -D instead of -d forces deletion

Review your work #

$ git log [-n count]

List commit history of current branch. -n count limits list to last n commits.

$ git log --oneline --graph --decorate

An overview with reference labels and history graph. One commit per line.

$ git log ref..

List commits that are present on the current branch and not merged into ref. A ref can be a branch name or a tag name.

$ git log ..ref

List commit that are present on ref and not merged into current branch.

$ git reflog 

List operations (e.g. checkouts or commits) made on local repository.

Tagging known commits #

$ git tag

List all tags.

$ git tag [name] [commit sha]

Create a tag reference named name for current commit. Add commit sha to tag a specific commit instead of current one.

$ git tag -a [name] [commit sha]

Create a tag object named name for current commit.

$ git tag -d [name]

Remove a tag from local repository.

Reverting changes #

$ git reset [--hard] [target reference]

Switches the current branch to the target reference, leaving a difference as an uncommitted change. When –hard is used, all changes are discarded.

$ git revert [commit sha]

Create a new commit, reverting changes from the specified commit. It generates an inversion of changes.

Synchronizing repositories #

$ git fetch [remote]

Fetch changes from the remote, but not update tracking branches.

$ git fetch --prune [remote]

Delete remote Refs that were removed from the remote repository.

$ git pull [remote]

Fetch changes from the remote and merge current branch with its upstream.

$ git push [--tags] [remote]

Push local changes to the remote. Use –tags to push tags.

$ git push -u [remote] [branch]

Push local branch to remote repository. Set its copy as an upstream.

The .gitignore file #

Sometimes it may be a good idea to exclude files from being tracked with Git. This is typically done in a special file named .gitignore. You can find helpful templates for .gitignore files at github.com/github/gitignore.

logs/ *.notes pattern*/

Save a file with desired patterns as .gitignore with either direct string matches or wildcard globs.

git config --global core.excludesfile [file]

system wide ignore pattern for all local repositories

Git Flow #

{ loading=lazy }

{ loading=lazy }

!!! tip You can use git-flow tool to manage git flow easier.
git-flow are a set of git extensions to provide high-level repository operations for Vincent Driessen’s branching model.

Glossary #

Term	Description
git	an open source, distributed version-control system
GitHub	a platform for hosting and collaborating on Git repositories
commit	a Git object, a snapshot of your entire repository compressed into a SHA
branch	a lightweight movable pointer to a commit
clone	a local version of a repository, including all commits and branches
remote	a common repository on GitHub that all team members use to exchange their changes
fork	a copy of a repository on GitHub owned by a different user
pull request	a place to compare and discuss the differences introduced on a branch with reviews, comments, integrated tests, and more
HEAD	representing your current working directory, the HEAD pointer can be moved to different branches, tags, or commits when using git switch