Skip to content

Git Commands

In this article, I am going to present a comprehensive cheat sheet of commonly used Git commands with examples.

Installing git

Here are the commands to install Git on different operating systems:

# Ubuntu/Debian:
sudo apt-get install git

# MacOS (using Homebrew):
brew install git

# Windows OS (using choco)
choco install git

Setting up git configuration:

To begin, it's important to configure your Git settings, associating your name and email with your commits. Use the following commands to set your name and email respectively:

git config --global "anji.keesari"
git config --global ""

Caching credentials:

Typing in login credentials repeatedly can be time consuming. To streamline this process, you can store your credentials in the cache using the command:

git config --global credential.helper cache

Enable automatic coloring of Git output

This command is used to enable automatic coloring of Git output in the command line interface. Enabling this option enhances the readability of Git's output by applying different colors to various elements.

git config --global color.ui auto

Checking git configuration:

To verify your Git configuration, including your username and email, use the following command:

git config -l

Initializing git

Before diving into Git commands, you need to initialize a new Git repository locally in your project's root directory. Execute the command:

git init

Git clone

To work on an existing Git repository, you can clone it using the command

git clone <repository-url>

Adding files to the staging area:

To stage changes and prepare them for commit, use the git add command. You can add specific files or entire directories to the staging area using the following commands:

git add <file-name>             # Add a specific file
git add .                       # Add all changes in the current directory (excluding deletions)
git add test*                   # Add all files starting with 'test' in the current directory

Committing changes:

Committing changes captures a snapshot of your code at a specific point in time. Use the following commands to commit your changes:

git commit -m "(message)"       # Commits the changes with a custom message
git commit -am "(message)"      # Adds all changes to staging and commits them with a custom message

Git log

To view the commit history of a repository, use the git log command. It provides you with an overview of past commits and their respective details. also, you can use git log -p to see the commit history along with the changes made to each file.

#  shows the commit history for the current repository:
git log
# commit's history including all files and their changes:
git log -p

press q any time to quit

Commit details

Use this command to see a specific commit in details

git show commit-id
Note: replace commit-id with the id of the commit that you can find in the git log

Git status

This command will show the status of the current repository including staged, unstaged, and untracked files.

git status

Undoing changes:

If you have already pushed a commit to a remote repository and want to undo it, you need to create a new commit that undoes the changes. The following command will create a new commit that undoes the changes introduced by the specified commit:

git revert <commit-id>
Replace with the ID of the commit you want to undo.

If you have already committed changes and want to undo the most recent commit, you have a few options depending on your desired outcome: - Undo the commit and keep the changes as unstaged modifications:

git reset HEAD^
Undo the commit and completely discard the changes:
git reset --hard HEAD^

Viewing differences

To compare the differences between versions, you can use the git diff command. It displays the changes made to files since the last commit.

git diff

This will show the line-by-line differences between the current state of the files and the last committed version.

Pushing changes

To push your local commits to a remote repository, you need to use following command.

git push origin <branch-name>

# if you haven't set the upstream branch yet, you can use this

git push --set-upstream origin aspnet-api

Pulling changes

Use this command to incorporate the latest changes from a remote repository into your local repository.

git pull origin <branch-name>

Git fetch

To fetch the latest changes from the remote repository without merging them into your local branches.

git fetch

Creating a new branch:

To create a new branch in Git, you can use the git branch command followed by the name of the branch you want to create.

git branch <branch-name>

# Creates a new branch, `aspnet-api` is name of the branch here
git branch aspnet-api

Switching branch:

To switch to a different branch in your Git repository, you can utilize the git checkout command followed by the name of the branch you want to switch to.

git checkout <branch-name>

# Switched to branch 'aspnet-api'
git checkout aspnet-api

List branches

It will show a list of all branches and mark the current branch with an asterisk and highlight it in green.

# Shows the list of all branches.
git branch  
# List all local branches in repository. With -a: show all branches (with remote).
git branch -a 

# press q to quit

Get remote URLs

You can see all remote repositories for your local repository with this command:

git remote -v

More info about a remote repo

How to get more info about a remote repo in Git:

git remote show origin

Merging branches

In Git, merging allows you to combine the changes from one branch into another. To merge a branch into another branch, you can use the git merge command followed by the name of the branch you want to merge. Here's an example:

git merge <branch-name>

# For instance, if you want to merge the changes from the develop branch into the main branch
# cd to the folder
git checkout main
git merge develop

After performing the merge, it's a good practice to check the status of your repository using git status to ensure that the merge was successful and there are no conflicts to resolve. also, you can view the commit history using git log to see the merged commits and their details.

git status
git logs

Delete branch

To delete a branch in Git, you can use either of the following commands:

git branch --delete <branch-name>
git branch -d <branch-name>

# git branch to see list of branches before delete
git branch
# delete the branch
git branch --delete <branch-name>
# git branch again to see list of branches after delete
git branch

Branch from a previous commit

To create a new branch in Git using a specific commit hash, you can use the git branch command followed by the name of the branch and the commit hash

git branch branch_name <commit-hash>
# Step 1: Create the branch from the commit hash

git branch new_branch 07615d50afde24d21e2180b90d3a0a58ec131980

# this will create the local branch

# Step 2: Switch to the new branch & commit

git commit -am (message) 

Rollback an old commit

You can revert an old commit using its commit id.

git revert comit_id

How to resolve merge conflicts using git commands

Resolving merge conflicts in Git involves editing the conflicted files to choose which changes to keep and which to discard, and then committing the resolved changes. Here's a step-by-step guide:

  1. Check the status of your repository to see if there are any merge conflicts:

    git status
    If there are merge conflicts, you will see a message indicating which files have conflicts.

  2. Open the conflicted files in a text editor and look for the conflict markers. The markers will look something like this:

    <<<<<<< HEAD
    This is the content from the current branch.
    This is the content from the branch you are merging.
    >>>>>>> <branch-name>
    1. Decide what changes you want to keep and remove the conflict markers and any unnecessary content. The final content should only include the changes you want to keep.

  3. Stage the changes using git add:

    git add <file-name>

  4. Commit the changes to the repository:
    git commit -m "Resolved merge conflicts"
  5. Push the changes to the remote repository if necessary:
    git push origin <branch-name>

Temporary commits

In Git, you can use temporary commits to store modified, tracked files temporarily, allowing you to switch branches without losing your changes. This is a useful technique when you want to work on a different branch but are not ready to commit your changes yet.

  • Stash your changes: This will create a temporary commit that stores your modifications, allowing you to switch branches.
    git stash
  • Git stash list Running this command will show you the stash ID, along with a description that includes the branch name and commit message.
    git stash list
  • Git stash pop: his command is used to apply the changes from the top of the stash stack and remove that stash from the stack.
    git stash pop:
  • Git stash drop: This command allows you to discard a stash from the stash stack. It permanently removes a stash and its changes, freeing up space in the stack.
    git stash drop: