I'm Mykel. I'm a self-taught programmer. I love to share what I leaned. This is my first write-up. I learned git recently and thought share it with you.

Git is the most used tool by developers. You can't help yourself to use it. Here we don't talk much about what is git. If you don't know about git, simply google it. I assume that you know about git. You want to learn git or maybe you know a bit and want to learn more then this article is right for you. I start from a stretch.

First download git from here . Download the file according to your OS and install it simply. It's so easy, trust me. Now create a folder and open the terminal in it. This is the right time to start learning git. To initiate git run the command down there.

Git Initial:

git init

Congrats, you have done very well. Let's proceed next steps. Now create some files in the folder. Use terminal or create visually. Let's think we have created one.txt and two.txt

To know about changes or status about files:

git status

Notice your created files are red marked. It's because don't to stage them yet. The stage is a medium state. There are some commands to staging files. Here are them.

To staging your changes:

git add --all

or

git add -A

It's worked for all files and directories. Including forward and backward.

git add .

Dot (.) do stage in all files which have (.) or ext. This works like going only forward. For example, if you are the main branch, you add dot(.), it will staging all files including the subdirectories. But if you are a directory, then you add dot(.), it's just staged those files which are in this directory and subdirectory of it but not those which are in the main directory.

git add *

This command will stage every file except deleted. This command doesn't stage any deleted files.

For a single file:

git add fileName.ext

Only for .txt files:

git add *.txt

Only for .js files:

git add *.js

After staging files will be green marked. Now you want to unstaged files and want to back in the working directory.

To unstaged:

git reset

After staging, commit your files and save them completely.

To commit or save your changes:

git commit -m "<message>"

After doing commit check git status. You see the working tree is clean, which means there is nothing to commit.

To uncommit or back to the working directory:

git reset HEAD~

Undo delete or reset changes with the hard file:

git reset --hard

But this reset will also remove untracked files and directories. Suppose your main directory is gitone(folder-name). Your this directory is now tracked. Now you created a new directory, for example, myFolder and three.txt in it. Now you deleted two.txt unconsciously and staged your changes. Then you notice your two.txt file is deleted and now you want to back this file. For this purpose, you use reset --hard. You definitely back your two.txt hard file but the newly-created directory myFolder and file three.txt will remove. Because the directory and file were untracked.

Git Remove:

git rm <fileName.ext>

The difference between manually delete and rm command is if you delete manually you have to add change using add command, but if use the rm command your hard file will be removed and change will be staged automatically.

To remove file forcefully:

git rm <fileName.txt> -f

Suppose your working tree is clean, nothing to add, and nothing to commit. Now edit a file like two.txt. and you don't add your changes yet. At this moment you want to remove your file two.txt with the rm command. But surprisingly you will see git doesn't let you remove the file. Do you know why? because you don't add and commit your file yet. So if you really want to remove your file and are fully aware that you want to get back the file later, you don't get the changes that you make now. To understand git that, use --f flag. Git will remove the file And understand that you know the consequences.

To remove folder:

git rm -r folderName

It will remove files and subfolders in it.

Branching:

Now we are going to learn about branch. It's the most interesting topic about git. First We should know what is Branch? Suppose you have done a project and deliver the project to the client. After few months your client wants to change in code or develop. Now can't touch your main code without fixing bug of new changes, right? Now, what are you do? copy the whole code in another folder then do changes? It's not sound good right! Here is the work of Branching. When you make a branch your branch will copy everything that you have in the main branch. Now see you have copy anything nor have to touch main code.

Now at first check, how many branches we have!

Check branch:

git branch

You got only the main branch right. okay, let's create a new branch.

Creating new branch:

git branch <branchName>

Again check branch now. you see created a new branch with the main branch. Now it's time to switch to our new branch.

Switching to branch:

git checkout <branchName>

There is a shortcut for creating and switching in a branch with one line of command.

Creating and switching in branch:

git checkout -b <branchName>

You still don't get it fully! Okay, I understand. Let's make it easier for you. Now you are in your new branch, right? let's think its name is development. Now in the development branch, we will create a file. For example, four.txt. add and commit the file. Check git status. Your working tree is clean, right!

Now switch branch development to main. Have you seen the four.txt file here? No, right! Now again switch to development. You see four.txt now. Hopefully, you got how branching works.

Merging:

We have a branch named development and that branch has some files. Now you are sure changes are ready for production or change are ready to merge with the main code/branch. Now switch to the main branch, if you have not yet. Then command,

To merge:

git merge <branchName> -m "message"

in our case, it will be like

git merge development -m "merging on main with development"

Now you can see all the files, you created in development branch merged in main branch.

Merging conflict:

Suppose your friend created a branch to change in some code. Let's say it staging. so now you are working on the development branch and your friend is working on staging. you and your friend change a common file. let's say it two.txt so you have changed something in two.txt and your friend too. But you both don't know about it. After changing you have added and committed. Now you think to merge your friend's branch staging with your branch. What you see! Git saying he is failed to auto merge. Because he doesn't know who's changes should be kept. And if you open the file which git has conflict to merge, in our case two.txt, has shown where the conflict is occurred in the code. Now you DM your friend and discuss what change should keep. After solve the conflict add and commit the file. Then DM your friend to merge with your branch.

Push Local to Remote:

It's time to push our files local to cloud. There is some cloud storage to share code such as GitHub, BitBucket, and GitLab. Here we are going to use GitHub. It's free and awesome. First you have to sign up in GitHub, if you don't do that yet. Go to GitHub and Sign up. I assume that you have sign up in GitHub and log in there. Now create a repository in GitHub and copy repository link. Suppose you create a repository name as gitTest. So your repository link will be like - https://github.com/your-user-name/gitTest.git

Now back to your terminal. First, switch to the main branch, if you are already switched then it's good. Set your remote origin to use the command.

Set remote origin:

git remote add origin <repository url>

Then push your code local to the cloud storage.

git push -u origin <branchName>

In our case,

git push -u origin main

A pop-up will appear and put your GitHub username and password. Now refresh your GitHub repository tab. You see your all files are pushed to the cloud. You notice the main branch has pushed only, other two branch doesn't. To push other branches also switch to those branches one by one and push.

Remote to local:

Still, we change our files in the local storage. Let's think you have changes some files in the cloud and you want to merge them in local too. Use this command to fetch changes remote to local.

git fetch

If you check git status you see nothing is there. Also, check your hard files. Nothing has changed right. Actually, the fetch command just fetches the changes, not the hard file. For merging hard files also, you have to command one more.

git merge

Now see hard file also change.

First, fetch and then merge, it's not cool right! Why not do it in one line. Here is it.

git pull

This command will fetch and merge the data automatically. Want to show your git commit history! simply command,

git log

You may want to clone other code repositories from the cloud storage. Here is the command for that.

Clone git repository:

git clone <repository link>

These are the basic things you should know to start work with git.

Happy coding! Control your program version with git and share your code through GitHub.

I appreciate sharing your thoughts about this article. Wanna give some advice, I'm all free to hear. Find it useful please share it with your friends to learn what you learned.