# Top 10 Git Commands Every Developer Should Know

Software developers tend to work in packs. We pool our creativity (and our code) to build software and our strength in numbers helps reduce the risk of errors. The more people who check code and scan for bugs, the cleaner our final product will be.

However, this places a premium on effective communication. We will end up accessing, reading, writing and changing the same files over and over again, and it’s vital we keep duplication of work to a minimum.

A `Version Control System(VCS)` is great for this. It’s a change management system that records all the changes to files and folders over a period of time. You can go back in history to fetch a specific version of the change you’re interested in, and it allows multiple people to collaborate on the same project without getting in each other’s way (a bit like Google Docs and Google Sheets allow us to collaborate on written documents).

`Git` is the most popular, most-widely used example of a VCS; today, in fact it’s used by over 90% of developers. However many people don’t know all the commands that `git` offers, so they may be missing out on some of its most powerful and beneficial features.

But fear not, coding comrades. In this post, we’re going to take you through the best commands, starting right from the very beginning.

But first, a quick clarification…

## Git ≠ GitHub

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1677230866911/08ca70cb-a6b8-4b77-bb74-a4cc7b4edf75.png align="center")

Some Git rookies may confuse it with GitHub and think both are the same. They are not.

Git is a version control system that helps track file and folder changes. These files and folders finally get pushed to a centralized place called `repository`. `GitHub` is a cloud-based application that helps you manage multiple repositories, and it’s also extremely popular (there are other alternatives to GitHub that serve the same purpose, but GitHub has attracted over 100 million developers).

Ok, on with the tutorial!

## Installation

Right, let’s start from the top.

You need to install Git on your computer before you start using it. You can install Git on Windows, Linux, and macOS operating systems.

### **On Windows**

You can find the official Git builds on the Git website. Download the installer from [https://git-scm.com/download/win](https://git-scm.com/download/win) and start the installation.

### **On Linux**

The easiest way to install Git on Linux is using the `apt`.

```bash
sudo apt install git-all
```

For RPM-based distributions, you can use the `dnf`.

```bash
sudo dnf install git-all
```

### **On macOS**

To install Git on macOS, visit the website [https://git-scm.com/download/mac](https://git-scm.com/download/mac) and follow the easy steps.

## Git CLI

Right, now the installation’s done, let’s go down into the engine room and look at command line interfaces (CLIs)

There are several graphical user interfaces (GUIs) available to carry out Git operations, but CLIs are the most powerful way to interact directly with Git commands. These user interfaces enable you to provide commands as simple lines of text, triggering a command-and-response interaction that is often faster than an alternative GUI.

After installing Git, you can use the terminal or command prompt to execute your commands. And when you install Git for Windows, `Git Bash` will make things even simpler by enabling CLIs for you. We assume you’ll be using Git CLI while learning all the commands discussed in this article.

## And Now… Onto The Git Commands

We’re going to run through 10 Git commands that are particularly useful when working with your team members. Let’s dive straight in….

### **1\. Configuring Git**

`git config` is a powerful Git command that helps customize Git’s workflow. Git creates a special file called `~/.gitconfig` to keep all these configurations, and you can add or override entries using the `git config` command.

Let’s start by setting a Git username and email:

```bash
git config --global user.name "Tapas Adhikary"
git config --global user.email "tapas@someemail.com"
```

You can read back these values as:

```bash
git config --list
```

Output:

```bash
user.name=Tapas Adhikary
user.email=tapas@someemail.com
```

When you open the global configuration file `~/.gitconfig`, you will see the content saved as:

```bash
[user]
    name = Tapas Adhikary
    email = tapas@someemail.com
```

### **2\. Initializing a Repository**

The `git init` command creates a new Git repository, a `.git` subdirectory which sits under the current working directory. This subdirectory contains all required metadata for the new repository.

You can use the `git init` command in two ways.

Either change a directory using the `cd` command and run `git init` to create a Git repository….

```bash
git init
```

Or create an empty Git repository by specifying a directory name using the `git init` command.

```bash
git init <directory-name>
```

### **3\. Cloning a Repository**

The `git clone` command helps you clone a local or remote repository by copying it into a new directory. You can work on the cloned copy in isolation by cloning the repository locally; after your modifications, you push the changes back to the remote repository.

You can clone a repository using HTTPS or SSH. Here is an example of how HTTPS looks.

```bash
git clone <https://github.com/reactplay/react-play.git>
```

This will clone the `react-play` project locally for you. Then you can change to the directory and start working on it.

```bash
cd react-play
```

### **4\. Staging/UnStaging Your Changes**

In the Git workflow, you modify the file locally, put it in a special area called `stage` and then put it into the project history before you finally push the changes to the remote repository. The staging area is a buffer where you can still do/undo some changes before putting them into the commit history. The `git add` command is used to send your file changes to the staging area.

```bash
git add <file-name>
```

Also,

```bash
git add <directory-name>
```

If you want to reverse operations and remove some changes before you write to the commit history, no worries: you can use the `git rm` command.

```bash
git rm <file-name>
```

### **5\. Status Check**

It is always important to check the state of the working directory and the staging area when working with Git. At a bare minimum, this will tell you exactly what is tracked vs untracked and what’s happening with your files.

```bash
git status
```

For output:

```bash
> git status
On branch main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean
```

If you want more detailed and verbose output, please use the `git log` command.

### **6\. Committing Your Changes**

The `git commit` command commits the files from the staging area and writes to the commit history, launching a text editor to provide a meaningful commit message.

Important: after you provide the message and save the file, all the changes will be committed.

```bash
git commit -m "a meaningful commit message"
```

### **7\. Push to the Remote**

The `git commit` command doesn’t push your local changes to the remote repository. For this, you need to use the `git push` command. This is how it should look:

```bash
git push <remote> <branch-name>
```

Please note that you can push single or multiple commits to the remote simultaneously.

### **8\. Pulling from the Remote**

The reverse of `push` is… yep, you guessed it `pull`.

The `git pull` command pulls the changes from the remote repository to your cloned workspace. With a pull, you can keep your working directory synced with all the changes being pushed to the remote by your team members.

```bash
git pull
```

Standard practice is to pull as a first step any time you work on a file and commit your changes.

### **9\. Merging**

Merging is a way to combine changes from two branches and integrate them into a single branch.

```bash
git merge <branch-name>
```

When multiple people are working on a target branch, they may want to get each other’s changes. The `git pull` won’t work here as these branches may not have merged to the `main` remote repository. Git merge combines multiple commit sequences into one history. At times, however, this function may make things difficult to debug.

As an alternative option, you can use `git rebase`.

### **10\. Branching**

The `git branch` command has several options for working with branches. Using this command, you can:

**List all the branches:**

```bash
git branch
```

**Create a new branch with a branch name**:

```bash
git branch <branch-name>
```

**Delete a specific branch**:

```bash
git branch -d <branch-name>
```

**Rename a branch**:

```bash
git branch -m <branch-name>
```

**List all Remote branches (with a marking of the current branch)**:

```bash
git branch -a
```

Additionally, when you want to switch from one branch to another, you can use the `checkout` command:

```bash
git checkout <branch-name>
```

## To Conclude

We hope this quick article has given you a decent snapshot of the most-useful Git commands. Remember, thought, that this is just the tip of the iceberg; there are many more commands to handle corner cases, edge cases and other rare but complex situations.

Before we go, though, I’ll leave you with a few additional resources that may help you to explore Git further.

* [Git Cheatsheet](https://www.atlassian.com/git/tutorials/atlassian-git-cheatsheet)
    
* [Demystifying Git for Beginners](https://youtu.be/vWtu4mzUgQo)
    
* [A Practical Guide to Resolve Merge Conflicts](https://www.freecodecamp.org/news/resolve-merge-conflicts-in-git-a-practical-guide/)
    
* [How Not to Use Git in Practice?](https://blog.greenroots.info/how-not-to-use-git-in-practice-ten-git-usages-you-should-know-to-avoid)
    

> This article was [**Originally Published on Bugfender**](https://bugfender.com/blog/top-10-git-commands-every-developer-should-know/).
> 
> `Bugfender` is a log storage service for application developers. It collects everything happening in the application, even if it doesn’t crash, in order to reproduce and resolve bugs more effectively and provide better customer support. Get started with Bugfender [**from here**](https://dashboard.bugfender.com/signup).

---

## **Before We End...**

Thanks for reading it. I hope it was insightful and helped you get familiar with git basics and commands. If you liked the article, please post likes and share it in your circles.

Let's connect. You can follow me on [**Hashnode**](https://hashnode.com/@atapas), and I also share tips on Software Development, Content Creation, Open Source, and Careers on these platforms.

* [**YouTube**](https://www.youtube.com/tapasadhikary?sub_confirmation=1)
    
* [**Twitter**](https://twitter.com/tapasadhikary)
    
* [GitHub](https://github.com/atapas)
    
* [**LinkedIn**](https://www.linkedin.com/in/tapasadhikary/)