{"id":75226,"date":"2018-03-29T22:00:22","date_gmt":"2018-03-29T19:00:22","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=75226"},"modified":"2023-12-11T10:42:14","modified_gmt":"2023-12-11T08:42:14","slug":"git-tutorial-for-beginners","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2018\/03\/git-tutorial-for-beginners.html","title":{"rendered":"Git Tutorial for Beginners"},"content":{"rendered":"

1. What is Git ?<\/h2>\n

Git<\/a>\u00a0is a popular file versioning system used globally by numerous developers for their projects. It is lightweight and swift in its performance as compared to the likes. With a number of UI based tools to assist in Git based versioning, it has become extremely convenient for the developers to use Git Versioning System. Git flaunts features like Cheap local branching, convenient staging areas and multiple workflow configurations.<\/p>\n

In this article, we would specifically focus on getting\u00a0 started with using Git and cover up some basic commands that would be needed for a simple project. The article covers every detail of possible situations that might come up during the versioning. However, before beginning with it, it is necessary to have Git Version Control System(VCS) installed onto your system.<\/p>\n

2. Git Installation<\/h2>\n

In order to install Git into your system, follow the steps shown below:<\/p>\n

2.1 Installing Git in Windows & MacOS<\/h3>\n
    \n
  1. Go to the home page of Git VCS<\/a><\/li>\n
  2. You should be able to find a download button for the latest Git version available<\/li>\n
  3. Download and install the same<\/li>\n<\/ol>\n

    In order to verify the installation, enter the below command in your command prompt(Windows) or Terminal(Mac OS).<\/p>\n

    $ git --version\n<\/pre>\n
    An output as shown below should appear if the installation went fine.<\/p>\n
    \"\"<\/a>
    Git Version Check<\/figcaption><\/figure><\/p>\n
    2.2 Installing Git Core in Linux<\/h3>\n
    Git does not provide ready to install setup files for Linux. Hence, there is an alternate way to get it installed instead. Execute the below command from the terminal to get the git-core<\/strong> package installed.<\/p>\n
    $ sudo apt-get install git-core\n<\/pre>\n
    This will do all the necessary steps and once it is ready, follow the below steps to verify the installation.<\/p>\n
    Enter the below command in your Terminal window.<\/p>\n
    $ git --version\n<\/pre>\n
    An output as shown above should appear if the installation went fine.<\/p>\n
    \"\"<\/a>
    Git Version Check<\/figcaption><\/figure><\/p>\n
    3. Starting with the Git versioning<\/h2>\n
    Once the installation is done and verified, we are all set to start with the first project versioning using Git. We would be working with a dummy Java project here to understand file versioning for a project better. You could use any popular IDE to create a Java project and get started. The IDE used here is Eclipse IDE. However, for the execution of commands, we would strictly restrict to the command line tools.<\/p>\n
    3.1 Creating and initialising a Git Repository<\/h3>\n
    In order to configure a project to use Git based versioning system, all you need to do is initialise the project directory as a GIT repository. Create a Java project in your desired directory using your preferred IDE.<\/p>\n
    Now, open up your terminal and change the directory to the project directory using the popular cd<\/code> command.<\/p>\n
    $ cd \/path\/to\/project\n<\/pre>\n
    To initialise the Git repository, execute the command git init<\/code>. The output as shown below should be visible.<\/p>\n
    $ git init\nInitialized empty Git repository in \/Users\/abhishekkothari\/Desktop\/JavaCodeGeeks\/GitBeginners\/GitBeginner\/.git\/\n<\/pre>\n
    As it can be seen, a .git<\/strong> directory is created in the project folder. This folder keeps a track of all the changes that take place locally. You can check the directory status by using the command git status<\/code>. It should provide an output similar to what is shown below. It might vary if you are using a different IDE.<\/p>\n
    $ git status\nOn branch master\n\nNo commits yet\n\nUntracked files:\n  (use \"git add ...\" to include in what will be committed)\n\n\t.classpath\n\t.project\n\t.settings\/\n\tbin\/\n\tsrc\/\n<\/pre>\n
    3.2 Beginning with the file versioning<\/h3>\n
    Now, in the project, create a Java file as shown below.<\/p>\n
    SayHello.java<\/em><\/span><\/p>\n
    package com.javacodegeeks;\n\npublic class SayHello {\n\tpublic static void main(String[] args) {\n\t\tSystem.out.println(\"Hello there!\");\n\t}\n}\n<\/pre>\n
    The IDE might show error for the package. Feel free to remove the package declaration if not required. Once the file is created, we need to add the file to the GIT index. This would ascertain that the changes to the files are tracked thereafter. To add the file to the index, execute the command git add \/path-to-file\/SayHello.java<\/code>. There would be no feedback to the command. However, you could check the status to ascertain the file is added to the index.
    \nOn checking the status, an output similar to the one shown below will be visible.<\/p>\n
    $ git add src\/com\/javacodegeeks\/SayHello.java \n$ git status\nOn branch master\n\nNo commits yet\n\nChanges to be committed:\n  (use \"git rm --cached ...\" to unstage)\n\n\tnew file:   src\/com\/javacodegeeks\/SayHello.java\n\nUntracked files:\n  (use \"git add ...\" to include in what will be committed)\n\n\t.classpath\n\t.project\n\t.settings\/\n\tbin\/\n<\/pre>\n
    The next step in the flow is to actually commit the file to the repository. A file being committed means the current version of file in the repository will be overwritten. A file can be committed using the command git commit<\/code>. It is also possible to add comments describing the changes that are being committed. In order to do so, execute the command as shown below.
     
    <\/div> <\/div><\/p>\n
    $ git commit -m \"First File Committed\"<\/pre>\n
    This would commit the file mentioning the comment First File Committed<\/strong> in the trace. An output similar to the one shown below should be visible.<\/p>\n
    $ git commit -m \"First File Committed\"\n[master (root-commit) 9cce524] First File Committed\n 1 file changed, 7 insertions(+)\n create mode 100644 src\/com\/javacodegeeks\/SayHello.java\n<\/pre>\n
    3.3 Working with multiple files<\/h3>\n
    File versioning is generally used when there are multiple files to work with. Hence, certainly there needs to be ways to work easily with multiple files rather than executing the\u00a0git add file-name<\/code> for each file to index every time. In order to understand the same, let’s create two more simple java files as shown under.<\/p>\n
    EvenNumbers.java<\/em><\/span><\/p>\n
    package com.javacodegeeks;\n\npublic class EvenNumbers {\n\tpublic static void printEvenNumber(int i) {\n\t\tSystem.out.println(\"Even numbers upto \"+i);\n\t\tfor(int x=0;x<i;x=x+2)\n\t\t\tSystem.out.println(x);\n\t}\n}\n\n<\/pre>\n
    OddNumbers.java<\/em><\/span><\/p>\n
    package com.javacodegeeks;\n\npublic class OddNumbers {\n\tpublic static void printOddNumber(int i) {\n\t\tSystem.out.println(\"Odd numbers upto \"+i);\n\t\tfor(int x=1;x<i;x=x+2)\n\t\t\tSystem.out.println(x);\n\t}\n}\n\n<\/pre>\n
    Now, we need to add these two files to index without executing command for each file. In order to do so, there are two ways. One of them is useful when you specifically wish to add files with a specific extension. For instance,<\/p>\n
    $ git add *.java\n<\/pre>\n
    The above command would add all the files with the extension .java<\/strong> to the staging. Staging is an area that holds the file version until it is committed. Another possible way is to add all the files that exist in the project using the below command.<\/p>\n
    $ git add -A\n<\/pre>\n
    This command would take care of all the files – New, Modified as well as Deleted. Let’s now modify the file SayHello.java<\/code> as shown below.<\/p>\n
    SayHello.java<\/em><\/span><\/p>\n
    package com.javacodegeeks;\n\npublic class SayHello {\n\tpublic static void main(String[] args) {\n\t\tSystem.out.println(\"Hello there!\");\n\t\tEvenNumbers.printEvenNumber(11);\n\t\tOddNumbers.printOddNumber(12);\n\t}\n}\n\n<\/pre>\n
    Now execute either of the above commands to add all the Java files to the staging area and then check the status. The status should be similar to the one shown below:<\/p>\n
    $ git status\nOn branch master\nChanges to be committed:\n  (use \"git reset HEAD ...\" to unstage)\n\n\tnew file:   src\/com\/javacodegeeks\/EvenNumbers.java\n\tnew file:   src\/com\/javacodegeeks\/OddNumbers.java\n\tmodified:   src\/com\/javacodegeeks\/SayHello.java\n\nUntracked files:\n  (use \"git add ...\" to include in what will be committed)\n\n\t.classpath\n\t.project\n\t.settings\/\n\tbin\/\n<\/pre>\n
    In case you used the command git add -A<\/code>, it would have added all the empty directories to the index too. If this is not as expected, you can easily undo the movement to stage by executing git reset<\/code>. It will reset the add action that was executed and revert the staging to the previous commit. An output similar to the one shown below will be available.<\/p>\n
    $ git reset\nUnstaged changes after reset:\nM\tsrc\/com\/javacodegeeks\/SayHello.java\n<\/pre>\n
    Once reset, you can add the expected files to the staging and commit once things look fine.
    \n[ulp id=’qqpFiv5a5W384Wlg’]
    \n <\/p>\n
    3.4 Connecting to the remote repository<\/h3>\n
    The changes tracked and stored during the above steps are all tracked locally. For now, the files are not available online for other developers to work on. In order to enable other developers to access or clone the code, it is important to connect the local code base to the remote repository. For this, you need to start by creating an online repository on popular Git hosting platforms like GitHub. For this article, I have created a repository GitBeginner<\/a> on Github. To connect the local files to the repository execute the below command.<\/p>\n
    $ git remote add origin https:\/\/github.com\/datsabk\/GitBeginner.git\n<\/pre>\n
    There would be no feedback for the command. However, you could check the successful connection by using below command.<\/p>\n
    $ git remote show origin\n* remote origin\n  Fetch URL: https:\/\/github.com\/datsabk\/GitBeginner.git\n  Push  URL: https:\/\/github.com\/datsabk\/GitBeginner.git\n  HEAD branch: (unknown)\n<\/pre>\n
    Now that the local files are connected to the remote repository, it’s time to push the files to the repository. To do so, execute the command shown below:<\/p>\n
    $ git push -u origin master\nCounting objects: 6, done.\nDelta compression using up to 4 threads.\nCompressing objects: 100% (2\/2), done.\nWriting objects: 100% (6\/6), 471 bytes | 157.00 KiB\/s, done.\nTotal 6 (delta 0), reused 0 (delta 0)\nTo https:\/\/github.com\/datsabk\/GitBeginner.git\n * [new branch]      master -> master\nBranch 'master' set up to track remote branch 'master' from 'origin'.\n<\/pre>\n
    Incase, you did not configure Git for the user details, you would be prompted to enter the credentials for your corresponding hosting account. You can configure your Git user name and password by following steps from this link<\/a>.<\/p>\n
    3.5 Git Branching and Merging<\/h3>\n
    In a large project, the developers do not usually work on a common branch. Every developer creates a branch with respect to the feature they are developing or the bug they are trying to resolve. This section covers the process of creating a branch and merging the same into the main branch.<\/p>\n
    First of all, let’s create a local branch. In order to create a new local branch, execute the command git checkout -b newbranch<\/code>. This will create a new local branch and switch to it. An output similar to the one shown below will be available.<\/p>\n
    $ git checkout -b newbranch\nM\tsrc\/com\/javacodegeeks\/SayHello.java\nSwitched to a new branch 'newbranch'\n<\/pre>\n
    Now, let us change some code in SayHello.java<\/code> as shown below:<\/p>\n
    SayHello.java<\/em><\/span><\/p>\n
    package com.javacodegeeks;\n\npublic class SayHello {\n\tpublic static void main(String[] args) {\n\t\tSystem.out.println(\"Hello there!\");\n\t\tSystem.out.println(\"Printing even numbers\");\n\t\tEvenNumbers.printEvenNumber(11);\n\t\tSystem.out.println(\"Printing odd numbers\");\n\t\tOddNumbers.printOddNumber(12);\n\t}\n}\n<\/pre>\n
    The developers occasionally need to check the differences between the files at the remote repository. Whenever this is required, simply execute the command git diff<\/code> to check all the modifications. An output similar to the one shown below will turn up.<\/p>\n
    $ git diff\ndiff --git a\/bin\/com\/javacodegeeks\/SayHello.class b\/bin\/com\/javacodegeeks\/SayHello.class\nindex 0e9d8e3..6c45444 100644\nBinary files a\/bin\/com\/javacodegeeks\/SayHello.class and b\/bin\/com\/javacodegeeks\/SayHello.class differ\ndiff --git a\/src\/com\/javacodegeeks\/SayHello.java b\/src\/com\/javacodegeeks\/SayHello.java\nindex 815b53a..4276f44 100644\n--- a\/src\/com\/javacodegeeks\/SayHello.java\n+++ b\/src\/com\/javacodegeeks\/SayHello.java\n@@ -3,7 +3,9 @@ package com.javacodegeeks;\n public class SayHello {\n        public static void main(String[] args) {\n                System.out.println(\"Hello there!\");\n+               System.out.println(\"Printing Even numbers\");\n                EvenNumbers.printEvenNumber(11);\n+               System.out.println(\"Printing Odd numbers\");\n                OddNumbers.printOddNumber(12);\n        }\n }\n\n<\/pre>\n
    As it can be noticed, there are +<\/strong> signs to indicate that the two lines were added. For the .class<\/strong> files, Git is unable to read them as text since they are binary byte codes. Hence, it merely says that they are different from what was committed earlier. Now, its time to push these changes and merge them to the master branch. The procedure to push the changes to the remote repository remains the same. Execute the commands as shown below:<\/p>\n
    $ git commit -m \"Added two lines\"\n[newbranch 3f7d0cb] Added two lines\n 1 file changed, 2 insertions(+)\nMacBook-Air:GitBeginner abhishekkothari$ git push -u origin newbranch\nCounting objects: 24, done.\nDelta compression using up to 4 threads.\nCompressing objects: 100% (18\/18), done.\nWriting objects: 100% (24\/24), 3.09 KiB | 791.00 KiB\/s, done.\nTotal 24 (delta 5), reused 0 (delta 0)\nremote: Resolving deltas: 100% (5\/5), done.\nTo https:\/\/github.com\/datsabk\/GitBeginner.git\n * [new branch]      newbranch -> newbranch\nBranch 'newbranch' set up to track remote branch 'newbranch' from 'origin'.\n<\/pre>\n
    Now the new branch has been created on the remote repository and the changes are pushed to the branch. However, the changes are not yet available in the master branch. In order to pull these changes into the master branch, raise a merge request using the Github UI as shown below.<\/p>\n
    \"\"<\/a>
    Raising Merge Request<\/figcaption><\/figure><\/p>\n
    Once the merge request has been raised, an authorised person can accept the request and pull the changes into the master repository and make it available to others. In a large project, there are frequent chances of having conflicts during merge. Conflicts occur when some other developer already merged the changes in a file that you are trying to merge. In such a case, Git is unable to decide whether the changes should be overwritten or merged.<\/p>\n
    A conflicting scenario has been generated in the above pull request by editing the\u00a0SayHello.java<\/strong> file in the master branch as shown below:<\/p>\n
    SayHello.java<\/em><\/span><\/p>\n
    package com.javacodegeeks;\n\npublic class SayHello {\n\tpublic static void main(String[] args) {\n\t\tSystem.out.println(\"Hi there!\");\n\t}\n}\n<\/pre>\n
    Once this change has been done, the pull request shows conflict as shown below:<\/p>\n
    \"\"<\/a>
    Merge Conflict in Git<\/figcaption><\/figure><\/p>\n
    These conflicts can be interactively resolved by clicking the Resolve conflicts and selecting the code that needs to be written to the file once merged. Such conflicts can be challenging at times. Hence, it is advisable to pull the latest changes to the files incrementally to avoid large chunk of conflicting code. The latest changes of any specific branch can be pulled by using the commands shown below:<\/p>\n
    $ git fetch origin\n$ git merge origin\/master\n<\/pre>\n
    The first command will pull the latest changes of the respective branch. The next command does the job of merging the fetched changes into the local files.<\/p>\n
    3.6 Ignoring certain files<\/h3>\n
    In the previous operations, we sticked to the git add *.java<\/code> command. However, this is not the case always. There might be a need where we wish to ignore only certain files rather than all. In such a case, below command comes in handy.<\/p>\n
    $ git rm -r --cached *.class\n<\/pre>\n
    On executing the above command and then checking the status of the repository, you would find that the class files are now being ignored and the output of git status<\/code> is similar to the one shown below.<\/p>\n
    $ git status\nOn branch newbranch\nYour branch is up to date with 'origin\/newbranch'.\n\nChanges to be committed:\n  (use \"git reset HEAD ...\" to unstage)\n\n\tdeleted:    bin\/com\/javacodegeeks\/EvenNumbers.class\n\tdeleted:    bin\/com\/javacodegeeks\/OddNumbers.class\n\tdeleted:    bin\/com\/javacodegeeks\/SayHello.class\n\nUntracked files:\n  (use \"git add ...\" to include in what will be committed)\n\n\tbin\/\n<\/pre>\n
    It indicates that the class files are deleted from the tracking list and the bin folder is now not being tracked. Thus, the files are now in the ignored list. This list can be found in .gitignore file located in the project directory.<\/p>\n
    4. Conclusion<\/h2>\n
    The article has covered in depth the complete process of creating and managing Git repository for a project as a beginner. It captures the basic problems or features that a developer might come across. There would be complex challenges ahead. However, Git being a popular versioning system, there should be sufficient help available for the same.<\/p>\n
    5. References<\/h2>\n