{"id":7649,"date":"2018-06-25T00:10:25","date_gmt":"2018-06-24T16:10:25","guid":{"rendered":"http:\/\/rmohan.com\/?p=7649"},"modified":"2018-06-25T00:10:25","modified_gmt":"2018-06-24T16:10:25","slug":"git-fundamentals","status":"publish","type":"post","link":"https:\/\/mohan.sg\/?p=7649","title":{"rendered":"Git Fundamentals"},"content":{"rendered":"

Git Fundamentals<\/h1>\n

 <\/p>\n

\n
\n
\n

Topics To be Covered<\/p>\n

    \n
  1. Installation<\/li>\n<\/ol>\n

    2. Setup<\/p>\n

    3. Creating a Project<\/p>\n

    4. Checking the status of the repository<\/p>\n

    5. Making changes<\/p>\n

    6. Staging the changes<\/p>\n

    7. Staging and committing<\/p>\n

    8. Commiting the changes<\/p>\n

    9. Changes, not files<\/p>\n

    10. History<\/p>\n

    11. Aliases<\/p>\n

    12. Getting older versions<\/p>\n

    13. Tagging versions<\/p>\n

    14. Discarding local changes (before staging)<\/p>\n

    15. Cancel Staged changes (before committing)<\/p>\n

    16. Cancelling commits<\/p>\n<\/div>\n<\/div>\n<\/section>\n

    \n
    \n
    \n<\/div>\n
    \n
    \n
    \n

    1. Installing Git<\/h3>\n

    Installing on\u00a0Linux<\/h4>\n

    If you want to install the basic Git tools on Linux via a binary installer, you can generally do so through the basic package-management tool that comes with your distribution. If you\u2019re on Fedora for example, you can use yum:<\/p>\n

    $ sudo yum install git-all<\/pre>\n
    If you\u2019re on a Debian-based distribution like Ubuntu, try apt-get:<\/p>\n<\/div>\n
    $ sudo apt-get install git-all<\/pre>\n
    For more options, there are instructions for installing on several different Unix flavors on the Git website, at\u00a0http:\/\/git-scm.com\/download\/linux<\/em><\/a>.<\/p>\n
    Installing on\u00a0Mac<\/h4>\n
    There are several ways to install Git on a Mac. The easiest is probably to install the Xcode Command Line Tools. On Mavericks (10.9) or above you can do this simply by trying to run\u00a0git<\/em>\u00a0from the Terminal the very first time. If you don\u2019t have it installed already, it will prompt you to install it.<\/p>\n
    If you want a more up to date version, you can also install it via a binary installer. An OSX Git installer is maintained and available for download at the Git website, at\u00a0https:\/\/sourceforge.net\/projects\/git-osx-installer\/<\/a><\/p>\n<\/div>\n<\/div>\n
    You can also install it as part of the GitHub for Mac install. Their GUI Git tool has an option to install command line tools as well. You can download that tool from the GitHub for Mac website, athttp:\/\/mac.github.com<\/em><\/a>.<\/p>\n
    Installing on\u00a0Windows<\/h3>\n
    There are also a few ways to install Git on Windows. The most official build is available for download on the Git website. Just go to\u00a0https:\/\/git-for-windows.github.io\/<\/a><\/p>\n<\/section>\n
    Another easy way to get Git installed is by installing GitHub for Windows. The installer includes a command line version of Git as well as the GUI. It also works well with Powershell, and sets up solid credential caching and sane CRLF settings. We\u2019ll learn more about those things a little later, but suffice it to say they\u2019re things you want. You can download this from the GitHub for Windows website, at\u00a0http:\/\/windows.github.com<\/em><\/a><\/p>\n
    2. One time Git Environment Setup<\/h3>\n
    Now that you have Git on your system, you\u2019ll want to do a few things to customize your Git environment. You should have to do these things only once; they\u2019ll stick around between upgrades. You can also change them at any time by running through the commands again.<\/p>\n
    Git comes with a tool called git config that lets you get and set configuration variables that control all aspects of how Git looks and operates. These variables can be stored in three different places:<\/p>\n
    $ git config?\u2014?global user.name \u201cAravind G V\u201d<\/p>\n
    $ git config?\u2014?global user.email aravind_gv@intuit.com<\/p>\n
    $ git config?\u2014?global core.editor \u201cedit -w\u201d<\/p>\n
    3. Creating a\u00a0Project<\/h3>\n
    Create a new repository<\/h4>\n
    Create a New Folder or Do in Existing Folder if you want to add it to vcs<\/p>\n
    mkdir training\r\ncd training\r\ntouch hello.txt<\/pre>\n
    Create a repository<\/h3>\n
    So you have a directory that contains one file. Run the git init in order to create a git repo from that directory.<\/p>\n
    RUN:<\/h4>\n
    git init<\/pre>\n
    RESULT:<\/h4>\n
    $ git init\r\nInitialized empty Git repository in \/Users\/agv\/git-training<\/pre>\n
    This creates a new subdirectory named\u00a0.git that contains all of your necessary repository files?\u2014?a Git repository skeleton. At this point, nothing in your project is tracked yet<\/p>\n
    Add the page to the repository<\/h3>\n
    Now let\u2019s add the \u201cHello, World\u201d page to the repository.<\/p>\n
    RUN:<\/h4>\n
    git add hello.txt\r\ngit commit -m \"First Commit\"<\/pre>\n
    You will see\u00a0\u2026<\/p>\n
    RESULT:<\/h4>\n
    $ git add hello.txt\r\n$ git commit -m \"First Commit\"\r\n[master (root-commit) 2fc4372] First Commit\r\n 1 file changed, 0 insertions(+), 0 deletions(-)\r\n create mode 100644 hello.txt<\/pre>\n
    Checking the status of the repository<\/h3>\n
    Use the git status command, to check the current state of the repository.<\/p>\n
    RUN:<\/h4>\n
    git status<\/pre>\n
    RESULT:<\/h4>\n
    $ git status\r\n# On branch master\r\nnothing to commit (working directory clean)<\/pre>\n
    The command checks the status and reports that there\u2019s nothing to commit, meaning the repository stores the current state of the working directory, and there are no changes to record.<\/p>\n
    We will use the git status, to keep monitoring the states of both the working directory and the repository.<\/p>\n
    Making changes<\/a><\/h3>\n
    Let\u2019s add some thing in text\u00a0file<\/h3>\n
    vi hello.txt\r\nTest status<\/pre>\n
    Checking the\u00a0status<\/h3>\n
    Check the working directory\u2019s status.<\/p>\n
    RUN:<\/h4>\n
    git status<\/pre>\n
    You will see\u00a0\u2026<\/p>\n
    RESULT:<\/h4>\n
    $ git status\r\nOn branch master\r\nChanges not staged for commit:\r\n  (use \"git add <file>...\" to update what will be committed)\r\n  (use \"git checkout -- <file>...\" to discard changes in working directory)\r\nmodified:   hello.txt\r\nno changes added to commit (use \"git add\" and\/or \"git commit -a\")<\/pre>\n
    The first important aspect here is that git knows hello.txt file has been changed, but these changes are not yet committed to the repository.<\/p>\n
    Another aspect is that the status message hints about what to do next. If you want to add these changes to the repository, use git add. To undo the changes use git checkout.<\/p>\n
    6. Staging the\u00a0changes<\/h3>\n
    Adding changes<\/h4>\n
    Now command git to stage changes. Check the status<\/p>\n
    RUN:<\/h4>\n
    git add hello.txt\r\ngit status<\/pre>\n
    You will see\u00a0\u2026<\/p>\n
    RESULT:<\/h4>\n
    $ git add hello.txt\r\n$ git status\r\n# On branch master\r\n# Changes to be committed:\r\n#   (use \"git reset HEAD <file>...\" to unstage)\r\n#\r\n#   modified:   hello.txt\r\n#<\/pre>\n
    Changes to the hello.txt have been staged. This means that git knows about the change, but it is not permanent in the repository. The next commit will include the changes staged.<\/p>\n
    Should you decide not to commit the change, the status command will remind you that you can use the git reset command to unstage these changes.<\/p>\n
    Staging and committing<\/h3>\n
    A staging step in git allows you to continue making changes to the working directory, and when you decide you wanna interact with version control, it allows you to record changes in small commits.<\/p>\n
    Suppose you have edited three files (a. html, b. html, and c. html). After that you need to commit all the changes so that the changes to a. html and b. html were a single commit, while the changes to c. html were not logically associated with the first two files and were done in a separate commit.<\/p>\n
    In theory you can do the following:<\/p>\n
    touch a.html b.html c.html\r\ngit add a.html\r\ngit add b.html\r\ngit commit -m \"Changes for a and b\"<\/pre>\n
    git add c.html\r\ngit commit -m \"Unrelated change to c\"<\/pre>\n
    Separating staging and committing, you get the chance to easily customize what goes into a commit<\/p>\n
    8. Committing the\u00a0changes<\/h3>\n
    Well, enough about staging. Let\u2019s commit the staged changes to the repository.<\/p>\n
    When you previously used git commit for committing the first hello.html version to the repository, you included the -m flag that gives a comment on the command line. The commit command allows interactively editing comments for the commit. And now, let\u2019s see how it works.<\/p>\n
    If you omit the -m flag from the command line, git will pop you into the editor of your choice from the list (in order of priority):<\/p>\n