Git Command Cheat Sheet (40+ Commands with Examples)

Introduction to Git Command Cheat Sheet

Git is one of the most widely used distributed version control systems used by developers to track changes, collaborate on projects, and maintain code history. Whether you are working on a personal project or contributing to a large team repository, understanding the most important Git commands can significantly improve your development workflow.

This Git command cheat sheet provides a quick reference to the most commonly used Git commands along with their syntax and examples. The goal is to help beginners quickly learn Git basics while also giving experienced developers a handy reference for daily development tasks.

In this guide, you will learn how to initialize repositories, stage and commit changes, manage branches, synchronize with remote repositories, and undo changes using commonly used Git commands. For a structured approach, see Git workflow guide.

Quick Git Command Cheat Sheet

This quick Git command cheat sheet summarizes the most frequently used Git commands for everyday development tasks. Use this table as a fast reference when working with repositories, branches, commits, and remote repositories.

These commands cover the most common Git operations performed during daily development workflows.

Most common Git commands quick reference table

The following table provides a quick overview of essential Git commands along with their purpose.

This table acts as a quick reminder of the commands most frequently used when working with Git.

Git workflow overview (working directory, staging area, repository)

The Git workflow revolves around three main areas: Working Directory, Staging Area, and the Local Repository. The diagram above shows how changes move through these stages before they are eventually shared with a remote repository such as GitHub, GitLab, or Bitbucket.

Understanding this workflow is essential because almost every Git command interacts with one of these stages.

Working Directory

The working directory is the location where you actively modify files in your project. When you create, edit, or delete files inside your project folder, those changes occur in the working directory.

At this stage Git can detect file changes but they are not yet part of the repository history. You can check the current state of files using:

git status

This command shows:

• Modified files
• New untracked files
• Files staged for commit

Changes in the working directory must first be added to the staging area before they can be committed.

Staging Area (Index)

The staging area, also called the index, is an intermediate step between the working directory and the repository. It allows you to review and select which changes should be included in the next commit.

You move changes from the working directory to the staging area using the git add command.

git add filename

To stage all files in the current directory:

git add .

The staging area helps developers create clean and meaningful commits by allowing them to group related changes together.

Local Repository

The local repository stores the complete commit history of your project on your machine. Once changes are staged, they can be permanently saved using the git commit command.

git commit -m "Add login feature"

Each commit represents a snapshot of the project at a specific point in time. Git assigns a unique commit hash to every commit, allowing developers to track and revert changes when necessary.

Remote Repository

After committing changes locally, developers often synchronize their repository with a remote server such as GitHub, GitLab, or Bitbucket. This allows teams to collaborate and share code.

Changes are uploaded to the remote repository using:

git push

To download the latest changes from the remote repository:

git pull

Typical Git Workflow

A typical Git workflow follows this sequence:

Modify files → git add → git commit → git push

1. Modify files in the working directory
2. Stage changes using git add
3. Save changes to the repository using git commit
4. Upload commits to the remote repository using git push

This workflow ensures that code changes are tracked, versioned, and safely shared with other developers.

Git Repository Setup Commands

These commands help you initialize a new repository, configure Git settings, and clone existing repositories from remote servers.

git init

Creates a new Git repository in the current directory.

git init

git clone

Creates a local copy of an existing remote repository.

git clone https://github.com/user/repository.git

git config

Configures global Git settings used for commits.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

Git Staging Commands

Staging commands allow you to select which changes should be included in the next commit.

git add

Adds the file to the staging area so it can be included in the next commit.

git add file.txt

git restore --staged

Removes a file from the staging area without deleting the file.

git restore --staged file.txt

git rm --cached

Removes a tracked file from Git but keeps the file in the working directory.

git rm --cached file.txt

Git Commit Commands

Commit commands record changes permanently in the Git repository.

git commit

Creates a new commit containing the staged changes.

git commit -m "Initial commit"

git commit -am

Stages and commits modified files in a single command.

git commit -am "Update README"

git commit --amend

Updates the last commit message or includes additional changes.

git commit --amend -m "Correct commit message"

Git Status and History Commands

These commands help inspect the current state of the repository and view commit history.

git status

Displays modified, staged, and untracked files.

git status

git log

Shows detailed commit history including author and timestamps.

git log

git log --oneline

Displays a condensed commit history.

git log --oneline

git reflog

Shows the history of HEAD changes and helps recover lost commits.

git reflog

Git Branch Commands Cheat Sheet

Branch commands allow developers to create, manage, and merge branches during development.

git branch

Lists all local branches.

git branch

git branch -d

Deletes a branch after it has been merged.

git branch -d feature-login

git checkout

Switches to the specified branch.

git checkout feature-login

git switch

Modern alternative to checkout for switching branches.

git switch feature-login

git merge

Combines changes from another branch into the current branch.

git merge feature-login

Git Remote Repository Commands

Remote repository commands allow you to connect your local Git repository to remote servers such as GitHub, GitLab, or Bitbucket. These commands help synchronize code between local and remote repositories.

git remote

Displays the list of configured remote repositories and their URLs.

git remote -v

git remote add

Adds a new remote repository named origin.

git remote add origin https://github.com/user/repo.git

git remote set-url

Updates the remote repository URL.

git remote set-url origin https://github.com/user/newrepo.git

git fetch

Downloads the latest commits and branches from the remote repository without merging them.

git fetch origin

git pull

Fetches the latest changes and automatically merges them into the current branch.

git pull origin main

git push

Uploads local commits to the remote repository.

git push origin main

Git Undo Commands

Git provides several commands to undo commits, unstage files, or revert changes safely such as git reset and git revert.

git reset

Removes a file from the staging area.

git reset HEAD file.txt

git reset --soft

Moves HEAD back one commit but keeps changes staged.

git reset --soft HEAD~1

git reset --hard

Completely removes the last commit and deletes all changes.

git reset --hard HEAD~1

git revert

Creates a new commit that reverses the changes from a previous commit.

git revert commit-hash

git restore

Restores a file to the last committed version.

git restore file.txt

Git Stash Commands

Git stash commands temporarily save uncommitted changes so you can work on another task without committing unfinished work using git stash.

git stash

Temporarily stores all uncommitted changes.

git stash

git stash list

Displays all saved stash entries.

git stash list

git stash apply

Applies the most recent stash but keeps it saved.

git stash apply

git stash pop

Applies the latest stash and removes it from the stash list.

git stash pop

Git Tag Commands

Tags are used to mark specific points in a repository history, usually for version releases.

git tag

Lists all existing tags.

git tag

git tag -a

Creates an annotated tag with a message.

git tag -a v1.0 -m "First release"

git push --tags

Pushes all local tags to the remote repository.

git push --tags

Git Debugging and Inspection Commands

These commands help inspect repository history, identify issues, and debug changes using git reflog and git blame.

git reflog

Shows the history of HEAD changes and helps recover lost commits.

git reflog

git bisect

Helps locate the commit that introduced a bug using binary search.

git bisect start

git blame

Displays who last modified each line in a file.

git blame file.txt

git show

Shows detailed information about a specific commit.

git show commit-hash

Git Bash Command Cheat Sheet

Git Bash provides a Unix-like command-line interface for Windows users to run Git commands and other shell utilities. It allows developers to interact with repositories, execute Git workflows, and automate development tasks directly from the terminal.

Most useful Git Bash commands

Git Bash supports both Git commands and standard shell commands, allowing developers to navigate directories and manage repositories efficiently.

pwd
ls
cd project-folder
git status
git branch

These commands help you navigate the project directory and check repository status.

Common Git Bash workflow examples

A typical workflow in Git Bash may look like this:

git clone https://github.com/user/project.git
cd project
git checkout -b feature-login
git add .
git commit -m "Add login feature"
git push origin feature-login

This workflow clones a repository, creates a new branch, commits changes, and pushes them to the remote repository.

Common Git Flags Cheat Sheet

Git commands support various flags that modify their behavior. Understanding these flags helps you perform operations more efficiently.

Git Workflow Quick Reference Table

The Git WorkFlow typically follows a sequence of commands that move changes from the working directory to the remote repository.

Complete Git workflow commands in order

The most common Git workflow includes the following steps:

git clone repository-url
git status
git add .
git commit -m "Update project"
git push origin main

Clone → Stage → Commit → Push workflow

The typical workflow used by developers is:

Clone repository
        ↓
Modify files
        ↓
git add
        ↓
git commit
        ↓
git push

This sequence ensures that changes are tracked locally before being shared with other collaborators.

Git Command Examples for Daily Development

Developers use Git commands repeatedly in daily workflows such as creating branches, updating repositories, and resolving conflicts.

Create new feature branch workflow

Developers often create feature branches to work on new functionality.

git checkout -b feature-login
git add .
git commit -m "Add login feature"
git push origin feature-login

This keeps development isolated from the main branch.

Pull latest changes from remote

Before starting new work, developers usually update their local repository.

git pull origin main

This ensures your local branch contains the latest commits from the remote repository.

Resolve merge conflicts

Merge conflicts occur when two branches modify the same file. After resolving conflicts manually, you can commit the changes.

git add resolved-file
git commit -m "Resolve merge conflict"

Summary

This Git command cheat sheet covered the most commonly used Git commands required for daily development workflows. You learned how to initialize repositories, manage branches, stage and commit changes, interact with remote repositories, undo commits, and inspect repository history.

By understanding these commands and workflows, developers can efficiently track changes, collaborate with teams, and maintain version control across projects. Keeping this cheat sheet handy can help you quickly recall commands and streamline your development process.

Official Documentation

• Git Official Documentation
• Git Command Reference
• Pro Git Book
• Git Glossary