Downloading a remote repository
If you like to copy a repository from Github.com (or any other remote address) to your local machine:
git clone https://email@example.com/nschlimm/spring-decorator.git
You can now work on the code and push the changes back to that remote repository if you like.
Working with branches - changing your current context
A branch in Git is nothing else but the "current context" you are working in. Typically you start working in the "master" branch. Let's say you want to try some stuff and you're not sure if what you're doing is a good idea (which happens very often actually :-)). In that case you can create a new branch and experiment with your idea:
git branch [branch_name]
When you just enter
git branchit will list your new branches.
If you'd like to work with your new branch, you can write:
git checkout [branch_name]
One important fact to notice: if you switch between branches it does not change the state of your modified files. Say you have a modified file
foo.java. You switch from
masterbranch to your new
some_crazy_ideabranch. After the switch
foo.javawill still be in modified state. You could commit it to
some_crazy_ideabranch now. If you switch to the
masterbranch however this commit would not be visible, 'cause you did not commit within the
masterbranch context. If the file was new, you would not even see the file in your working tree anymore.
If you want to let others know about your new idea you push the branch to the remote repository:
git push [remote_repository_name] [branch_name]
pushto get the changes in a remote branch into your local repository again.
This is how you delete a branch again if you don't need it anymore:
git branch -d [branch_name]
If you accidentally committed something to a branch you can easily remove the file again. For example, to remove the
readme.txtfile in your current branch:
git rm --cached readme.txt
--cachedoption only removes the file from the index. Your working directory remains unchanged.
You can also remove a folder. The
.settingsfolder for an eclipse project - for instance - is nothing you should share with others:
git rm --cached -r some_eclipse_project/.settings
After you ran the
rmcommand the file is still in the index (history of Git version control). You can permanently delete the complete history with this command:
Note: be very careful with commands like this and try them in a copy of your repository before you apply them to your productive repository. Always create a copy of the complete repository before you run such commands.
git filter-branch --index-filter 'git rm --cached --ignore-unmatch [your_file_name]' HEAD
Ignoring files: you do not want to version control a certain file or directory
To ignore files you just add the file name to the
.gitignorefile in the directory that owns the file. This way it will not be added to version control anymore. Here is my
.gitignorefor the root directory of an Eclipse project:
/target /.settings .project .classpath
It ignores the
.settingsfolder as well as the
Sometimes its helpful to configure global ignore rules that apply to the complete repository:
git config --global core.excludesfile ~/.gitignore_global
This added the following entry to my
.gitconfigglobal parameters file which resides in the git root directory.
excludesfile = d:/dev_home/repositories/git/.gitignore_global
These are my current global exclude rules in my
# Compiled source #
# Logs and databases #
Note: these rules are shared with other users. Local per-repo rules can be added to the .git/info/exclude file in your repo. These rules are not committed with the repo so they are not shared with others.
Restoring files - put the clocks back
Sometimes you make changes to your files and after some time you realize that what you've done was a bad idea. You want go back to your last commit state then. If you made changes to your working directory and you want to restore your last HEAD commit in your working directory enter:
git reset --hard HEAD
This command sets the current branch head to the last commit (HEAD) and overwrites your local working directory with that last commit state (the
--hardoption). So it will overwrite your modified files.
Instead of HEAD (which is your last commit) you could name a branch or a tag like 'v0.6'. You can also reset to a previous commit: HEAD~2 is the commit before your last commit.
May be you want to restore a file you have deleted in your working directory. Here is what I've entered to restore a java file I have deleted accidentally:
git checkout HEAD sources/spring-decorator/src/test/java/com/schlimm/decorator/simple/SetupSession.java
Again: Instead of HEAD you could name a branch or a tag like 'v0.6'. You can draw the file from a previous commit: HEAD~2 is the commit before your last commit.
Working with tags - making bookmarks to your source code
Sometimes you want to make a version of your source code. This way you can refer to it later on. To apply a version tag v1.0.0 to your files you'd write:
git tag -a v1.0.0 -m "Creating the first official version"
You can share your tags with others in a remote repository:
git push [remote_repository_name] --tags
remote_repository_nameis the alias name for your remote repository. You write
pushto get tags that others committed to the remote repository down to your local repository.
If you just enter
git tagit will give you the list of known tags. To get infos about the v1.0.0 tag, you'd write:
git show v1.0.0 -s
If you want to continue work on a tag, for instance on the production branch with version v5.0.1, you enter:
git checkout v5.0.1 -b [your_production_branch]
Note that this command also creates a new branch for the tag, this way you can make commits and anything else you wish to record back to the repository.
That's all for now. These commands and the ones from my last post should give you everything you need for the day-to-day work with Git. Go experiment a little. Type
git help [command]to get to the Git manual page. And don't forget to celebrate if you get all the stuff running :-)