vogella.de

Configure your user and your email for git via the following command.

				
# Config the user which will be used by git
# Of course you should use your name
git config --global user.name "Lars Vogel"
# Same for the email addess
git config --global user.email "Lars.Vogel@gmail.com"
# Set default so that always all changes are pushed to the repository
git config --global push.default "matching"

			

Create some content which we later put under version control.

				
#Switch to home
cd ~/
# create a directory
mkdir repo01.git
# switch into it
cd repo01.git
# create a new directory
mkdir datafiles
# Create a few files
touch test01
touch test02
touch test03
touch datafiles/data.txt
# put a little text into the first file
ls >test01

			

Create a Git repository, add the files and commit your changes.

				
# Initialize the local Git repository
git init
# Add all (files and directory) to the Git repository
git add .
# Make a commit of your file to the local repository
git commit -m "Initial commit"
# Show the log file
git log


			

We will now setup a remote repository which would be usually hosted on a webserver. Git allows to store this "remote" directory also locally and we will use this option.

				
# Switch to first repository
cd ~/repo01.git
# 
git clone --bare . ../remote-repository.git

# Check the content, should be equal to the .git file in repo01.git
ls ~//remote-repository.git

			

Do some changes and push them from your first repository to your second one via the following commands.

					
# Make some change in the first repos
cd ~/repo01

# Make some changes in the file
echo "Hello, hello. Turn your radio on" > test01
echo "Bye, bye. Turn your radio off" > test02

# commit the changes, -a will commit change changes for modified files
# but will not add automatically new files
git commit -a -m "Some changes"

# push the changes
git push ../remote-repository.git

				

Checkout a new version of your repository into a new directory via the following commands.

					
# Switch to home
cd ~
# make new directory
mkdir repo02.git 

# Switch to new directory
cd ~/repo02.git
# 
git clone ../remote-repository.git .

				

In your new repository, make some changes, push them to your remote repository and pull these changes from your first repository.

					
# Switch to home
cd ~

# Switch to second directory
cd ~/repo02.git
# Make changes
echo "A change" > test01
# Commit
git commit -a -m "A change"
# Push changes to remote repository
git push ../remote-repository.git/
# Switch to the first repository can pull in the changes
cd ~/repo01.git
git pull ../remote-repository.git/
# Check the changes
less test01

				

You can checkout older revisions of your source code via the hashcode.

					
# Switch to home
cd ~/repo01.git 
# get the log
git log

# Copy one of the older hashcodes and checkout the older revision vis 
git checkout HASHCODE


				

Create and use branches via the following command.

					
# Create a new branch
git branch mybranch
# Use this new branch
git checkout mybranch
# Do some changes
touch test04
# Commit these to the branch
git add .
git commit -a -m "First commit in the branch"
# Switch back to the master (this is always the main branch)
git checkout master
# Check that you have not test04 file
ls
# Merge your branch with the master 
git merge  mybranch
git add .
git commit -a -m "Merged branch"
# Delete the branch as it is not needed anymore
git branch -d  mybranch



				

The following helps you to see the changes in your repository.

					
// See the status
git status
// Shows a log file of the commits
git log
// This start a nice graphical view of the changes
gitk --all

				

The following creates a branch, makes some changes in this branch, creates a patch and applies the patch to the master.

					
# Create a new branch
git branch mybranch
# Use this new branch
git checkout mybranch
# Do some changes
touch test05
# Change some content in an existing file
echo "New content for test01" >test01
# Commit these to the branch
git add .
git commit -a -m "First commit in the branch"
# Create a patch --> git format-patch master
git format-patch origin/master
# Creates patch 0001-First-commit-in-the-branch.patch
# Switch to the master
git checkout master
# Apply the patch
git apply 0001-First-commit-in-the-branch.patch
# Do your normal commit in the master 
git add .
git commit -a -m "Applied patch"
# delete the patch 
rm 0001-First-commit-in-the-branch.patch