Basic Git commands you should know
Tags: git, github, beginners
Published: 2020-01-03 17:25:47

This post was originally posted in [johnraptis.dev](https://www.johnraptis.dev/git-basic-commands/)

Git and Github play an essential role in every developers workflow. They give us a very sophisticated way to keep track of our projects history. Knowing how to use them give us the ability to work more efficiently.

The purpose of this article is more of a reminder or general overview and to have things grouped in one place, rather than a comprehensive guide. I think the official documentation does a very good job in that respect.

##prerequisites

- Have Git installed in your system.

- Have a Github account and know the basics of creating a repository.

But first a quick reference.

##So what is Git?(Quickly)

Git is a system that tracks changes in our code. You will often hear it being referred as 'version control'. Why?
Because it keeps a history of all previous versions of our source code. This gives the ability to have multiple developers working in parallel and sharing code. In order to do that we would have a local Git repository which lives locally in our computer, and a remote Git repository which lives in a server(Github, Gitlab, etc..).

###git config
In order to work locally we will have to set our username and email.
This information will be used when we are doing commits to remote repositories, and should match you Github profile credentials.

We can do this globally.

```
git config --global user.name "John Doe"
git config --global user.email johndoe@example.com
```

. . . or in a single repository.

```
git config user.name "John Doe"
git config user.email johndoe@example.com
```

To check your information you can either do

```
git config user.name
> Joe Doe
```

```
git config user.email
> johndoe@example.com
```

or

```
git config --list
```

which returns them as part of a list

```
. . .
. . .
. . .
user.name=John Doe
user.email=johndoe@example.com
```

###git init
Initialize or reinitialize and existing repository with a <code> .git</code> folder that tracks our project locally.

###git add . / git add <file>
When we make a change we want to commit it to our local repository. But before we do that the code has to be added to the staging area. The staging area keeps track of the files that are about to be committed.

To have a better understanding of git you should have the following mental frame in mind.
Git has three states. The first is if a file is modified, which means any change you might have done. The second is if a file is staged, which means if you prepared the file to be committed. And lastly if a file is committed, which means that our changes have been stored to our local repository, ready to be pushed.

To add a single file to the staging area you type...

```
git add [name-of-file]
//ex  git add index.html
```

or with the <code> .</code> you add all the files that has been changed.

```
git add .
```

###git commit -m "message"

Now that we added our code to the staging area, we are ready to commit the file. We also give a descriptive name like "form added" or "updated version". etc. . .

###git status

With <code> git status</code> we can see in which phase our files currently are. Which files are modified, which ones are in our staging area or being committed and in which branch we currently are.

###git log

With log we see all the commits from the very beginning up until now. It also shows the name of who authored the commit and the date.

##Branches

We can create other branches as well to work on other versions or parts of our project. By default we commit all our code to the main branch which is called <code> master</code>. We can merge branches together if needed.( this will be covered later)

To create another branch.

```
git branch [name_of_branch]

git branch new_branch
```

To switch branches.

```
git checkout [name_of_branch]

git checkout new_branch
```

To create a new branch and switch into the new branch with one command.

```
git checkout -b [name_of_branch]

git checkout -b new_branch
```

To delete a branch.

```
git branch -D [name_of_branch]

git branch -D new_branch
```

...and to see a list of all your branches

```
 git show-branch
```

###git merge

Lets say you made some changes in your new branch and want to merge it to the master branch. Head to the master branch and run the merge command with the name of the branch you want to take the code from.

```
git merge [new_branch]

// in master branch
git merge new_branch
```

###git push

After you commit your code to your local Git repository you will want to push your code to a remote Git repository so other people can view and pull your code. With <code> git push</code> we will have to specify the <code> origin</code> and which branch we want to push.

<code>origin</code> is the url of our remote Git repository. It's something like this.

```
// remote url https://github.com/[username]/[repository-name].git

git push origin master
```

###git pull
Now lets say we are working alongside other developers. Everyone is working on different stuff and we want to get the latest version of our source code, so everyone can be in the same page. In this case we have to pull the code from the remote Git repository, everyone is pushing to(in our case Github), to our local Git repository.

###git clone

With git clone you copy a remote repository locally in your machine.

```
git clone https://github.com/[username]/[repository-name].git
```

###git remote set-url /git remote add  
Now in some cases you might want to change the URL of an existing repository, or add a new URL so we can push our code to a second repository as well.

To add a remote URL

```
git remote add origin https://github.com/[username]/[repository-name].git
```

**Note:** The name origin is a convention. It could be anything, like banana.

To replace an existing URL

```
git remote set-url origin https://github.com/[username]/[repository-name].git
```

To see a list of our repository remote URL's

```
git remote -v

origin  https://github.com/[username]/[repository-name].git (fetch)
origin  https://github.com/[username]/[repository-name].git (push)
```

If you want to add a second remote URL you still do git remote add but with a different name, other that origin.

```
git remote add banana https://github.com/[username]/[repository-name].git
```

Our list again

```
git remote -v

origin https://github.com/[username]/[repository-name].git (fetch)
origin https://github.com/[username]/[repository-name].git (push)
banana https://github.com/[username]/[repository-name].git (fetch)
banana https://github.com/[username]/[repository-name].git (push)
```

###git diff
Show's us the difference between our commits and our working tree. What is in the staging area, waiting to be committed. You can also see difference between branches and such if you dig deeper.

###git reset
Goes back in time to a specific version of our code. Since we are dealing with different states we will use different flags in each case.

Let's say you made some changes and committed them. Now you want to return to the previous version that was committed. Since each commit comes with a unique number you can do.

```
git reset --soft 9e5e6a4
```

By adding the <code>--soft</code> flag we will go back to those commits but our staging area and working directory will stay as is. If we do a <code>git commit</code> we will commit our current changes from the staging area.

```
git reset --mixed 9e5e6a4
```

If we do the same but we use the <code>--mixed</code> flag instead, we will go back again up until the staging area of that commit.

If we do <code>git commit</code> nothing will happen since the staging area matches the what is ready to be committed.

```
git reset --hard 9e5e6a4
```

And by adding the <code>--hard</code> flag the same will apply but the changes will go back to the working directory, like nothing was added or committed.

> To learn more about **reset** you can check [this](https://git-scm.com/book/en/v2/Git-Tools-Reset-Demystified).

##using ssh

If you don't want to be prompt to type your username and password each time you make a push you can provide an ssh key to your Github settings so Github can identify you.

To generate a new SSH key type

```
ssh-keygen
```

This will generate a public and a private file named <code>id_rsa.pub</code> and <code>id_rsa</code> respectively. It will ask you where to save the files. By default it saves them in the users folder with a folder name <code>.ssh</code>.
Head to your Github profile settings and look in the sidebar for **SSH and GPG keys** section.
Press **New SSH key**. In here you name and paste your public SSH key.

When creating a new repository you will have the option to set the URL of your repository as <code>HTTPS</code> or <code>SSH</code>.
Choose <code>SSH</code> so the whole process can work.

If you want to change the URL from an existing repository first created with <code>HTTPS</code> , you can do the following.

As we saw before

The <code>git remote -v</code> will list your repo's path.

```
git remote -v

origin https://github.com/[username]/[repository-name].git (fetch)
origin https://github.com/[username]/[repository-name].git (push)
```

With <code>git remote set-url</code>

```
git remote set-url origin git@github.com:USERNAME/REPOSITORY.gi
```

Check again

```
git remote -v

origin git@github.com:[username]/[repository-name].git (fetch)
origin git@github.com:[username]/[repository-name].git (push)
```

Now each time you make a push Github knows who you are.