DEV Community: Rajeev Bera

Top 35 Git Commands with Examples (and a Bonus)

Rajeev Bera — Tue, 11 May 2021 06:33:37 +0000

If you are a new or experienced developer, you have to use source control. And good chances are you are using Git to manage your source code.

And to use Git to its full potential, you need to know Git commands. Here you will learn the most helpful Git commands that will take you from one level to another.

To make this Git commands guide more helpful, I have divided the guide into three different sections: Basic, Intermediate, and Advanced Git commands.

This is an epic guide. And to make it more useful, I have added a Bonus section where you can download 51+ Git commands and a few more downloads to boost your productivity in Git.

Download PDF section

51+ Best Git Commands

Git HEAD: The Definitive Guide

Git best practices

Basic Git Commands

In this section, you will learn the essential Git commands. These basic Git commands are the foundation to learn more advanced commands.

Here are the nine useful Git commands

1. git config

Git config command is super helpful. Especially when you are using Git for the first time, or you have a new Git installation. This command will set up your identity — Name and Email address. And this information will be used with every commit.

Usage

$ git config — global user.name “Your name”
$ git config — global user.email “Your email”

2. git version

As its name implies, it’s just to check which version of Git you are using. At the moment, writing this guide, the latest version of Git for Windows is 2.31.1. It was released on 27th March 2021.

Usage

$ git version

3. git init

This is probably the first command you use to start a new project in Git. This command will create a blank new repository, and then you can store your source code inside this repo.

Usage

$ git init

Or you can use the repository name with your git init command.

$ git init [your repository name]

4. git clone

The git clone command will use an existing repository to copy. There is one main difference between the git init and git clone. You will use the Git clone when you need to make a copy on an existing repository.

The git clone command internally uses the git init command first and then checks out all its contents.

Usage

git clone [your project url]

5. git add

The Git add command will add all the new code files or modified files into your repository. This command offers different options to add files and folders.

Here is the usage of the Git add command.

Usage

$ git add your-file-name

(it will add single file to your the staging area)

$ git add *

( this option will add all the modified and new files to the staging area)

6. git commit

This Git command is essential. Your project quality may drop if you will not use this command appropriately.

There is another article about how to use Git commands property, and you can read that here.

In simple words, git commit will add your changes to your local repository.

Usage

$ git commit -m “your useful commit message”

7. git status

This Git command is convenient to see how many files are there which need your attention.

You can run this command at any time. You can use it in between Git add, and Git commits to see the status.

Usage

$ git status

8. git branch

Most of the time, you have multiple branches in your Git repository. In simple terms, the branch is an independent line of code development.

With the Git branch command, you can manage your branches effectively. There are many different options and switches of the Git branch.

To make it simple, here I will highlight how you can create and delete a Git branch. And, in case you need more depth, you can refer to — Git Branching & Merging section of this article

Usage

(i) To list all branches
$ git branch

(ii) To create a new branch
$ git branch

(iii) To delete a branch
$ git branch -d

9. git checkout

This Git command is used to switch between branches. This is one of the powerful git commands and can use used as a swiss knife,

In simple words, here is the syntax to switch to another branch.

Usage

$ git checkout

Also, you can create and checkout to a branch in a single like, here is the usage for that

$ git checkout -b

Intermediate Level Git Commands

After the basic Git commands, it’s time to share with you intermediate Git commands; these Git commands are super helpful if you need to collaborate with your team, share your code with others.

Also, there are commands like Git log that will help to see the history of previous commits.

10. git remote

Git remote command acts like a border, and If you need to connect with the outside world, you have to use the Git remote command. This command will connect your local repository to the remote.

Usage

$ git remote add

Example

$ git remote add origin https://dev.azure.com/aCompiler/_git/DemoProject

11. git push

Once you are connected with the remote repository (with the help of the git remote command), it’s time to push your changes to that repository.

Usage

$ git push -u

Example

$ git push -u origin feature-branch

You should have origin and upstream set up before you use Git push. And here is the command to set up upstream.

$ git push — set-upstream

$ git push — set-upstream origin feature-branch

13. git fetch

When you need to download other team members’ changes, you have to use git fetch. This command will download all information for commits, refs, etc.,

so you can review it before applying those changes in your local repository.

Usage

$ git fetch

14. git pull

The Git pull command downloads the content (and not the metadata) and immediately updates your local repository with the latest content.

Usage

$ git pull

15. git stash

This Git command temporarily stores your modified files. You can work in stashed with the following Git command.

Usage

$ git stash

And you can view all of your stashes with the following command

$ git stash list

And if you need a apply a stash to a branch, simply use apply

$ git stash apply

16. git log

With the help of the Git log, you can see all the previous commits with the most recent commit appear first.

Usage

$ git log

By default, it will show you all the commits of the currently checked out branch, but you can force it to see all the commits of all the branches with all option.

$ git log — all

17. git shortlog

The shortlog command shows you a summary from the Git log command. This command is helpful if you are just interested in the short summary.

This command is helpful to see who worked on what as it group author with their commit.

Usage

$ git shortlog

18. git show

Compared to the Git log, this command git show will show you details about a specific commit.

Usage

$ git show

19. git rm

Sometimes you need to delete files from your codebase, and in that case, you can use the Git rm command.

It can delete tracked files from the index and the working directory.

Usage

$ git rm

20. git merge

Git merge helps you to integrate changes from two branches into a single branch.

Usage

$ git merge

This command will merge the into your current selected branch.

Advanced Level Git Commands

And now the time to up one more level. In this section, you will learn the advanced Git commands. These commands will take time and practice. Once you know the basics of these commands, it will be easy to use them every day.

21. git rebase

Git rebase similar to the git merge command. It integrates two branches into a single branch with one exception. A git rebase command rewrites the commit history.

You should use the Git rebase command when you have multiple private branches to consolidate into a single branch. And it will make the commit history linear.

Usage
$ git rebase

22. git bisect

The Git bisect command helps you to find bad commits.
Usage

i) To start the git bisect
$ git bisect start

ii) let git bisect know about a good commit
$ git bisect good a123

iii) And let git bisect know about a bad commit
$ git bisect bad z123

With Git bisect you can narrow down the broken code within a few minutes.

23. git cherry-pick

Git cherry-pick is a helpful command. It’s a robust command and allows you to pick any commit from any branch and apply it to any other branch.

Usage

$ git cherry-pick

Git cherry-pick doesn’t modify the history of a repository; instead, it adds to the history.

24. git archive

Git archive command will combine multiple files into a single file. It’s like a zip utility, so it means you can extract the archive files to get individual files.

Usage

$ git archive — format zip HEAD > archive-HEAD.zip

It will create a zip archive of the current revision.

25. git pull — rebase

Most of the time, you need to do rebase (and no merge) when you use Git pull.

In that case, you can use the option
$ git pull — rebase

It will help you to keep the history clean. Also you can avoid multiple merges .

26. git blame

If you need to examine the content of any file line by line, you need to use git blame. It helps you to determine who made the changes to a file.

Usage

$ git blame

27. git tag

In Git, tags are helpful, and you can use them to manage the release. You can think of a Git tag like a branch that will not change. It is significantly more important if you are making a public release.

Usage

$ git tag -a v1.0.0

28. git verify-commit

The git verify-commit command will check the gpg signature. GPG or “GNU Privacy Guard” is the tool used in sign files and contains their signatures.

Usage
$ git verify-commit

29. git verify-tag

In the same way you can confirm a tag.

Usage

$ git verify-tag

30. git diff

Most Of the time, you need to compare two git files or branches before you commit or push. Here is a handy command to do that.

Usage

i) to compare working directory with local repo
$ git diff HEAD

ii) to compare two branches
$ git diff

31. git citool

Git citool is a graphics alternative of the Git commit.

Usage

$ git citool

32. git mv

To rename a git file. It will accept two arguments, source and target file name.

Usage

$ git mv

33. git clean

You can deal with untracked files by using the Git clean command. You can remove all the untracked files from your working directory by using this command.

In case you want to deal with tracked files you need to use the Git reset command.

Usage

$ git clean

34. git help

There are many commands in Git, and if you need more help with any command, you can use git help at any time from the terminal.

Usage

$ git help

35. git whatchanged

This command does the same thing as git log but in a raw form. And it’s in the git because of historical reasons.

Usage
$ git whatchanged

Bonus Section

As not, you know the Git commands, and it is time for the bonus section.

Here I will share with you Git best practices and downloadable material so you can read in your own time.

First, let’s talk about the free download that I would love to share with you,

Download PDF section

51+ Best Git Commands

Git HEAD: The Definitive Guide

Git best practices

Git Best Practices

Here I will share in brief one of the favourite Git best practice — AFTER technique

A — Atomic commits
F — Frequent commits
T — Test before your push
E — Enforce standards
R — Refactoring is not a feature

I hope you enjoyed this article. These Git commands will take your skills to the next level.

For such informative articles, please join aCompiler’s newsletter.

Parallel Programming In Git

Rajeev Bera — Mon, 12 Oct 2020 05:56:20 +0000

There are many Git Tips and Git Best Practices that can help you in your day to day activities. You will save you valuable time, and with these Git tricks, you can improve your workflow.

In this post, you will learn Parallel Programming in Git (in 2 minutes)

In case you want to download 31 Advanced Git tips, you can download in a printable pdf form here.

So let's start!

Imagine, You are working on a large legacy project in the Git repo. And at some hours you have to support the project and at other hours you have to add new features.

And to be honest, this is quite common in many organizations.

Now you can not switch between branches all the time - it might take quite a long time to complete the switch as it is a large project. And if you do switch via your IDE, it might crash.

Let me share one another example - You can in the middle of your adding a new feature, and at the same time, a new live bug reported, which is critical to fix. How yo deal with this.

There are a few ways to achieve this like you can stash your changes. But in this case, one of the best ways is to work on bug fixing and adding new features without switching the branches. And yes, it is possible in Git.

You can use the Worktrees to achieve parallel programming in Git.

In this post, I will share 3 Worktrees Git commands so you can achieve the parallel programming.

Worktree

Before that, let's see the basics of worktree. Git worktree command allows you to have multiple working directories associated with one git repo. A git repository can support multiple working trees, allowing you to check out more than one branch at a time.

Now let's see three Git commands to manage worktree.

Worktree Terminology

By default you have only one worktree; it is known as the Primary / Main worktree. And a newly created worktree known as Linked worktree.

View Your Worktrees

Before creating a worktree, you can view how many worktree you currently have. You can use a simple Git command.

git worktree list

It will display all the worktrees available in your Git repo.

Add a New Worktree

Let’s add a new worktree and see how you can use it.

git worktree add <your new work tree name>

The above command will create a new worktree. You can confirm it by simply list all your worktree with the git worktree list command.

Here is the screenshot.

As you can see in the above screenshot, you have two worktree in the same repo.

Technically at the same time, you can fix some bugs and add new features in the Git repo without checkout any other branch.

Delete a Worktree

Once you are done with your new feature, You can simply delete your worktree with a simple command.

git worktree remove <your worktree name>

Conclusion

Git is a powerful version control system. There is no doubt that with Git Best Practices, you can improve the git workflow and overall efficiency.

By default, there is only one working directory with your repo. And with the help of Git worktree, you can have multiple working directories.

In Linked working trees, you can not have the same branch name-checked out.

Hope with these simple commands, you can achieve parallel programming.

Let me know your thoughts.

How to DIG in Git: Best Practices

Rajeev Bera — Fri, 14 Aug 2020 12:54:24 +0000

This is one of the easiest best practices which you can start using in less than 2 minutes. But the impact will be huge.

Today I will share one of my all-time favorite practice - DIG in your GIT

And I have a bonus section for you, I am sharing two downloadable pdf with 51+ important git commands with a one-line summary and 35+ git best practices with you in this post.

Don’t Ignore .gitignore (DIG) in your Git repository. I have noticed in the past many developers do not use a .gitignore file.

Use the .gitignore file is one of the git best practices. And I will cover in this post how gitignore can boost your code quality with other advantages.

Also, I will explain how you can use your global .gitignore file (without adding or pushing). And this comprehensive file will be used by all your repository.

So let’s dive in…

What is .gitignore?

There is not any git ignore command which you can use directly to ignore the unwanted files in your repository; instead, you should use .gitignore file.

In simple words, the .gitignore file is a text file that tells Git about which files to ignore.

Git checks three things in your working copy.

Untracked - Your changes that have not been staged or committed.

Tracked - Your all changes that have been previously staged or committed.

Ignored - All files which you told to Git to ignore.

It's easy to create .gitignore file, create a text file, and name it .gitignore (that’s it)

Remember to add a single dot . at the beginning of this file name.

How many types of .gitignore files?

I have seen many developers use the local .gitignore file. They add the gitignore file in their project repository. But very few use the global file. In this section, I will explain both.

Keep reading...

There are two types of .gitignore files.

Local .gitignore file

If you add the.gitignore file in the root of your git repository, it will be considered as a local file. It means that the .gitignore file will work on that repository. And .gitignore file should be committed to your repository.

Global .gitignore file

If you place a similar file in the root of your home directory, it will act as a global .gitignore file.

What is means?

This file affects every repository you use on your machine.

The most significant advantage of using a global file is that you don’t need to commit it. And making one change affects all of your repositories.

Basic Rules for .gitignore file

Each line in the .gitignore file specifies a pattern. Here are some basic rules that help you to set up the .gitignore file

Any line in the .gitignore file starts with a hash (#) is a comment.
\ character is used to escape special characters
/ figure indicates that the rule applies only to files and folders, which are located in the same folder
An asterisk (*) means any number of characters (zero or more occurrence)
Two asterisks (**) are used to specify any number of subdirectories
A question mark (?) replaces zero or one character.
An exclamation sign (!) indicates the inversion rules.
Blank lines are ignore
You can ignore entire directories paths and adding a / on end:

What Files Should Be Ignored

You can ignore many files which are usually auto-generated, platform-specific, and other local configuration files.

Files with sensitive information
Compiled code, such as .dll or .class
System files like .DS_Store or Thumbs.db
Files with temporary information like a log, cache, etc..
Generated files like dist folders

Advantages of using gitignore

Here the top 3 advantages (that’s why I use .gitignore)

It helps you to clean your code repository by ignoring unwanted files.
Your repository size stays under control, especially if you are working on a big project.
Your every single commit, push, and pull request will be clean.

There is no doubt that Git is powerful. But in the end, it's just another computer program.

So it's a team effort to use best practices and to keep your code repo stable and make sure you use git ignore file.

Bonus

Its time for the Bonus download, you can download the 51 git commands from here

And 35+ Git best practices from here.

So let me know did you prefer local gitignore or global gitignore file

How you can Boost your Productivity and Code Quality in 5 days ... (PROVEN TECHNIQUE)

Rajeev Bera — Fri, 10 Jul 2020 05:29:57 +0000

There are more than 35 git best practices that are available on the web.

The web is full of Information... It's HUGE.

BUT the truth is different

It's not easy to achieve code quality by using all these git best practices and with many advance git commands.

Why?

It's hard to remember everything.

And second, it's not easy to implement, especially if you are a part of a big team.

Solution?

The AFTER technique

Before you jump in detail...

I have something to share

I used this technique and notice the boost in productivity and overall code quality improves within 5 days.

Find full case study here

"How I Boost My Productivity With AFTER Technique in 5 Days"

So let's dive into the more details of this technique

A — Atomic Commits

One of the important and without a doubt, best practices in any version control is to keep your commits atomic.

In simple words...

Atomic commit = one commit for one change.

example

git commit -m "Add JS validation to the user signup form"

F — Frequent Commits

The second rule of AFTER technique is F — Frequent commits.

Anytime I complete a part of code that compiles and runs, I prefer to commit.

T — Test Before You Push

I have never met any programmer who can write perfect code. To err is human.

It's important to test code before you commit and especially push to the remote repository.

E — Enforce standards

Adopting standards are essential.

They accelerate overall quality, and there is no doubt that full compliance always minimizes errors and delays.

These standards depending on the team and other factors.

You are read more about these standards here on Git Commands

R — Refactoring Is Not a Feature

Code refactoring is a normal thing in developers.

But the worse thing is refactoring and adding a new feature in the same commit.

You should not treat refactoring as a new feature and never mix these two things.

Code refactoring is not adding any value to the business.

That's it.

Bonus Section

Here is the bonus section for you.

You can download from here - Git Best Practices and AFTER techniques.

Leave a comment and let me know your thoughts.

ABC of Git Commands

Rajeev Bera — Wed, 24 Jun 2020 18:07:43 +0000

If you work as a developer, you probably already know about Git and Git Commands. And today, I will share straightforward & important stuff about Git Commands.

Before that one question.

Do you know the three essential things in human life?

Your Health
Your Financially stability
And your relationship

Yes, Once you have all these basic you can achieve anything else.

And the only purpose of this article to motivate you about GIT.

Git is really easy to learn.

Anyways. Let's come back to our original topic.

In the same way if you the essential commands in Git - You can extend your learning in Git to any level.

Without any further delay, let me share the ABC of Git.

But before that -

To understand these commands you might have to cover few other commands ( especially if you are a newbie)

A - Add ( git add command)

Syntax git add

To add multiple files use a single dot . or -A option

Syntax git add . ( to add multiple files)

With the git add command, you can add new files to the staging area.

B - Branch ( git branch command)

And one of the most significant advantages of Git is its branching model.

Here is the syntax so create and delete a branch

git branch (to create a new branch)

git branch -d (to delete a local branch)

C - Commit & Checkout ( git checkout and git commit command)
If you want to switch and create a new branch, you can use the checkout command with -b option.

git branch (to create a new branch)

git checkout (to navigate between the branches)

If you really want to learn more in-depth you can view my latest blog post here, and let me know in comments your thoughts.

I have a gift - infographic with 51+ Git commands.

It will help you to jump you from Intermediate to advanced level.

Also if you are looking for a cheat sheet pdf, you can grab that from aCompiler blog.

The only purpose of this article to show you two things

It's not hard to learn Git
And to share Git cheat sheet that really helped me. Download infographics and PDF.

Do you like or dislike the ABC of Git?

If you want to connect with me you can email me or write to me here.

Either way, let me know your thoughts.

Basic Git Commands

Rajeev Bera — Mon, 15 Jun 2020 04:22:47 +0000

If you want to use git to it's full potential, you must know about Git commands.

Why?

Can you drive a car if it's does not have any fuel ?
No

Fuel is an essential element for car.

Similarly, Git commands are essentials. You have to master this skill at some stage, especially if you are a software developer.

Git is popular,Microsoft uses git. So there is no doubt why its important.

And today I will show you five basic git commands which will help you to a kick start your git journey.

git --version

git add

git add -A

git status

git commit -m “your commit message”

So lets dive in more details

git --version

You can check your current version if git with git --version command

With this you can make sure that you are not using the old version.

git add

Git add command will use to add new files to the staging area.

With the gid add command you can add single file to the staging area

git add -A

And with git add -A command you can add multiple files into the staging area.

Here -A is a switch or option and A stands for all.

Also you can use git add . command, to add all files into the git staging area.

git status

It is one of the important command. You can check your current branch and list of files which are required to commit

git commit -m “your commit message”

Once you are ready to commit your changes it's time to commit.

Here -m option stand for your message. You want to commit with some message so you can refer that later.

Also in case if you want yo update your last commit message you can use

git commit --amend -m "your updated commit message"

So basically, git commit will add your changes to git repository from staging.

What is git staging area

Pictures speak louder than words.

Here is the one

Basically staging is a middle step between your working directory and repository.

I have a complete list and a bonus cheat sheet for you to download here.

Hope it's easy for your to understand these git commands.

Let me know in by comment about your git journey.