Git is a version control system, that was designed by Linus Torvalds, first released in 2005. In opposite to CVS (concurrent version systems) systems, which in it’s basics have a file as a processing item, in the Git basics lays work with the set of changes, other words, patches. This article dedicated to that persons, that is already familiar with the version control systems, such as SVN, and wants to know more about alternative version control solutions and persons that wants to get a tutorials about quick migration to the Git.

First difference that comes into view, is that Git is oriented to work with the local repositories. So basic operations, like commit are performed for the local repository on your computer. Let’s take a simple guide for the basic operations you gonna use. Checking out the project copy from the repository on the server is performed by operation git clone.

git clone gitosis@git.yourserver.com:yourproject.git /home/homeDir/myProjectCode language: PHP (php)

Now you have local copy of the repository in myProject directory and you are going to work on some new feature. The best practice of doing it is to create a new branch. By default, after you have cloned the repository, you are at the branch called master, you may tell that, after viewing the branches with the command git branch -a. Active branch is marked by the star. You may create new branch with the command git branch.

#creating new branch 'feature'
git branch feature
#switching to the branch that you created
git checkout feature
#or do the same operations in one line
git checkout -b featureCode language: PHP (php)

Notice that this operation didn’t create a new directory. All required info is in the .git directory. Using of the local branches very convenient. Imagine that you work on some serious feature, that isn’t done yet, project isn’t currently work as it should and you need to make a quick bugfix on the production version. I know that this is a nightmare for everyone that have used the CVS. But in Git, you simply switching the branch for example to the master running this command:

git checkout master

Do the bugfix, commit the changes and get back to work on your feature. The only moment about switching the branch is if you haven’t done that part of work yet, that could be a commit, but you need to switch the branch now, or you need to make some other changes to current branch, you will need to use stashing first. To reset your working tree and save your changes to the stash, apply this:

git stash save “Work in progress for feature foo” 

Now you may do the bugfix or something like this, commit the changes and now return to working on your feature.

git apply stash

This will return the changes you’ve stashed. In case if you have stashed more than one feature, you may list all of them running command

git stash listCode language: PHP (php)

and return one, specifying the stash you want this way:

git stash apply stash@{1}Code language: CSS (css)

Now let’s talk about interacting with the remote repository. As I said before, commit is performed on your computer, so how to get your changes to the remote repository? It is actually done in three stages. First, when you create some file in the project, it is untracked, and when you will commit the changes, the untracked files won’t be commited. Here are the basic commands that are used for indexing:

#indexing newFile file
git add newFile
#reset index for newFile file 
git rm newFile
#indexes all the untracked files
git add .Code language: PHP (php)

To look at the indexed files that awaits commit, and files that are not indexed yet on the current branch use command git status. In every development process, there are some files that shouldn’t be on the server, like files, created by the development framework, or files in out/ and target/ directories, that contains compiled files. If you will not ignore them, command git add . becomes useless. To ignore some files, create a file named .gitignore in the top level directory of your project. For example, you want to exclude files with extension .foo and to exclude all the files in directory /out, so your gitignore file
should be look like this:

*.foo
/out

Now, when you will run git status, it won’t show you excluded files as ones that awaits indexing. Now, you are ready to commit the changes.

#commits and writes a commit message
git commit -m "Initial commit"
#indexing all the untracked files, commits and writes a commit message
git commit -a -m "Initial commit"Code language: PHP (php)

Now you have several options available, depending on how you are planning to use this branch. If you are the only person that is gonna work with the branch, switch to the master branch, and run

git merge feature

That will merge the changes, made in feature branch to the master branch. Next, and the last step to get your changes on the server, run the command

git push

If you are already finished the work in branch, you may delete it:

git branch -d feature

But what if several people are going to work with the branch you created? In this case, you should push the branch to the server.

git push origin feature:refs/heads/feature

Where origin is the repository name, refs/heads/feature is the path to the branch description, that is placed in the /.git directory. In the last versions of Git, you may use

git push origin feature:feature.Code language: CSS (css)

Further, you may update the branch this way:

git pull origin feature

In case if you want to join the development for one of the branches run this:

git checkout --track -b feature origin/feature

This will create local branch feature and switch to it. Another convenience about Git is how reverting of the changes implemented here. In case if you haven’t commited undesirable changes yet, you may revert the working tree by running this:

git reset --hard HEAD

For restoring one file run following commands:

git checkout -- foo.bar
git checkout HEAD foo.barCode language: CSS (css)

If you have already commited one, but changes are not public yet, you may modify the last commit with the new one, just use flag –amend while commiting. But if the changes are already public, you should never use it. In this case use

git revert HEAD

It will create commit, that is undoing all the changes in HEAD. So this is the basics you should know to start working with Git.
To learn more about Git, please read documentation.